kiwi-code 0.0.9__tar.gz → 0.0.11__tar.gz

{kiwi_code-0.0.9 → kiwi_code-0.0.11}/PKG-INFO

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

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

{kiwi_code-0.0.9 → kiwi_code-0.0.11}/src/kiwi_runtime/main.py

@@ -117,7 +117,7 @@ TEXT = [
     "╚═╝  ╚═╝╚═╝ ╚══╝╚══╝ ╚═╝    ╚═╝  ╚═╝╚═╝",
 ]
 
-TAGLINE = "Terminal Agent for AI-Powered Automation"
+TAGLINE = "Runtime for AI-Powered Automation"
 
 
 def print_banner():

kiwi_code-0.0.11/src/kiwi_tui/inline_file_picker.py

@@ -0,0 +1,163 @@
+"""Inline file picker dropdown that appears when user types @ in chat input."""
+
+import os
+from pathlib import Path
+
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.message import Message
+from textual.widget import Widget
+from textual.widgets import OptionList, Static
+from textual.widgets.option_list import Option
+from rich.text import Text
+
+
+class InlineFilePicker(Widget):
+    """Dropdown file picker that shows above the input bar when @ is typed.
+
+    Displays files/dirs in CWD with '+' prefix, filterable by typing after @.
+    """
+
+    DEFAULT_CSS = """
+    InlineFilePicker {
+        dock: bottom;
+        height: auto;
+        max-height: 14;
+        width: 100%;
+        background: $surface;
+        border-top: solid #444444;
+        padding-bottom: 2;
+        display: none;
+    }
+
+    InlineFilePicker.visible {
+        display: block;
+    }
+
+    InlineFilePicker #file-option-list {
+        height: auto;
+        max-height: 12;
+        width: 100%;
+        background: $surface;
+        scrollbar-size: 1 1;
+        border: none;
+    }
+
+    InlineFilePicker #file-option-list > .option-list--option-highlighted {
+        background: $primary-background;
+        color: #00ffff;
+        text-style: bold;
+    }
+
+    InlineFilePicker #file-picker-header {
+        height: 1;
+        width: 100%;
+        padding: 0 1;
+        color: #888888;
+        text-style: italic;
+    }
+    """
+
+    class FileSelected(Message):
+        """Posted when a file is selected from the picker."""
+        def __init__(self, path: str) -> None:
+            super().__init__()
+            self.path = path
+
+    class Cancelled(Message):
+        """Posted when the picker is dismissed without selection."""
+        pass
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._base_path = os.getcwd()
+        self._all_entries: list[tuple[str, str]] = []  # (display_name, full_path)
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="file-picker-header")
+        yield OptionList(id="file-option-list")
+
+    def show_picker(self, filter_text: str = "") -> None:
+        """Show the picker with files from CWD, optionally filtered."""
+        self._base_path = os.getcwd()
+        self._refresh_entries(filter_text)
+        self.add_class("visible")
+
+    def hide_picker(self) -> None:
+        """Hide the picker."""
+        self.remove_class("visible")
+
+    @property
+    def is_visible(self) -> bool:
+        return self.has_class("visible")
+
+    def _refresh_entries(self, filter_text: str = "") -> None:
+        """Refresh the file list, optionally filtered."""
+        option_list = self.query_one("#file-option-list", OptionList)
+        header = self.query_one("#file-picker-header", Static)
+        option_list.clear_options()
+        self._all_entries = []
+
+        try:
+            entries = sorted(Path(self._base_path).iterdir(), key=lambda p: (not p.is_dir(), p.name.lower()))
+        except PermissionError:
+            header.update("  Permission denied")
+            return
+
+        filter_lower = filter_text.lower()
+
+        for entry in entries:
+            name = entry.name
+            if filter_lower and filter_lower not in name.lower():
+                continue
+
+            if entry.is_dir():
+                display = f"+ {name}/"
+            else:
+                display = f"+ {name}"
+
+            self._all_entries.append((display, str(entry)))
+            option_list.add_option(Option(Text(display, style=""), id=str(entry)))
+
+        if self._all_entries:
+            header.update(f"  Files in {self._base_path}")
+            option_list.highlighted = 0
+        else:
+            header.update(f"  No matches in {self._base_path}")
+
+    def filter(self, text: str) -> None:
+        """Filter entries by text."""
+        self._refresh_entries(text)
+
+    def _handle_selection(self, full_path: str) -> None:
+        """Handle selection: navigate into directories, select files."""
+        p = Path(full_path)
+        if p.is_dir():
+            self._base_path = str(p)
+            self._refresh_entries("")
+        else:
+            self.post_message(self.FileSelected(full_path))
+
+    def select_highlighted(self) -> None:
+        """Select the currently highlighted entry."""
+        option_list = self.query_one("#file-option-list", OptionList)
+        if option_list.highlighted is not None and self._all_entries:
+            idx = option_list.highlighted
+            if 0 <= idx < len(self._all_entries):
+                _, full_path = self._all_entries[idx]
+                self._handle_selection(full_path)
+
+    def move_highlight(self, delta: int) -> None:
+        """Move the highlight up or down."""
+        option_list = self.query_one("#file-option-list", OptionList)
+        if option_list.highlighted is None:
+            option_list.highlighted = 0
+        else:
+            new_idx = option_list.highlighted + delta
+            if 0 <= new_idx < len(self._all_entries):
+                option_list.highlighted = new_idx
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        """Handle click on an option."""
+        if event.option.id:
+            self._handle_selection(event.option.id)

{kiwi_code-0.0.9 → kiwi_code-0.0.11}/src/kiwi_tui/main.py

@@ -3,6 +3,7 @@
 import collections
 import os
 import subprocess
+from pathlib import Path
 
 from textual.app import App
 from textual.binding import Binding
@@ -40,7 +41,7 @@ class AutobotsTUI(App):
     """
 
     TITLE = "Kiwi Code"
-    SUB_TITLE = ""
+    SUB_TITLE = str("~" / Path.cwd().relative_to(Path.home())) if Path.cwd().is_relative_to(Path.home()) else str(Path.cwd())
 
     SCREENS = {
         "login": LoginScreen,

kiwi_code-0.0.11/src/kiwi_tui/screens/attach_content.py

@@ -0,0 +1,111 @@
+"""Attach content modal screen — file browser or URL input."""
+
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Static, Button, Input
+from textual.containers import Vertical, Horizontal
+from textual.binding import Binding
+
+
+class AttachContentScreen(ModalScreen[dict]):
+    """Modal for attaching content: browse files or add a URL.
+
+    Returns a dict: {"type": "files"} to open file browser,
+    {"type": "url", "url": "<value>"} for a URL, or {} if cancelled.
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=True),
+    ]
+
+    CSS = """
+    AttachContentScreen {
+        align: center middle;
+    }
+
+    #attach-container {
+        width: 60;
+        height: auto;
+        max-height: 20;
+        background: $surface;
+        border: solid #00d4d4;
+        padding: 1 2;
+    }
+
+    #attach-title {
+        width: 100%;
+        text-align: center;
+        text-style: bold;
+        color: #00ffff;
+        height: 1;
+        margin-bottom: 1;
+    }
+
+    #url-input {
+        width: 100%;
+        border: solid #00d4d4;
+        margin-bottom: 1;
+    }
+
+    #url-input:focus {
+        border: solid #00ffff;
+    }
+
+    #attach-buttons {
+        height: 3;
+        width: 100%;
+        align: center middle;
+    }
+
+    .attach-btn {
+        margin: 0 1;
+        background: #006666;
+        color: #00ffff;
+        border: solid #00d4d4;
+    }
+
+    .attach-btn:hover {
+        background: #008888;
+    }
+
+    #cancel-attach-btn {
+        background: $surface;
+        color: $text;
+        border: solid #444444;
+    }
+
+    #cancel-attach-btn:hover {
+        background: #333333;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="attach-container"):
+            yield Static("Attach Content", id="attach-title")
+            yield Input(placeholder="Paste a URL...", id="url-input")
+            with Horizontal(id="attach-buttons"):
+                yield Button("Add URL", id="add-url-btn", classes="attach-btn")
+                yield Button("Browse Files", id="browse-files-btn", classes="attach-btn")
+                yield Button("Cancel", id="cancel-attach-btn")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        btn_id = event.button.id or ""
+        if btn_id == "add-url-btn":
+            url = self.query_one("#url-input", Input).value.strip()
+            if url:
+                self.dismiss({"type": "url", "url": url})
+            else:
+                self.query_one("#url-input", Input).focus()
+        elif btn_id == "browse-files-btn":
+            self.dismiss({"type": "files"})
+        elif btn_id == "cancel-attach-btn":
+            self.dismiss({})
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "url-input":
+            url = event.value.strip()
+            if url:
+                self.dismiss({"type": "url", "url": url})
+
+    def action_cancel(self) -> None:
+        self.dismiss({})

{kiwi_code-0.0.9 → kiwi_code-0.0.11}/src/kiwi_tui/screens/dashboard.py

@@ -2,22 +2,26 @@
 
 from textual.app import ComposeResult
 from textual.screen import Screen
-from textual.widgets import Header, Footer, Input, Static, Button
+from textual.widgets import Header, Footer, Input, Static, Button, Markdown
 from textual.containers import Vertical, VerticalScroll, Horizontal
 from kiwi_tui.screens.file_browser import FileBrowserScreen
+from kiwi_tui.screens.attach_content import AttachContentScreen
+from kiwi_tui.screens.slash_picker import SlashPickerScreen
 from kiwi_tui.widgets import ChatInput
+from kiwi_tui.inline_file_picker import InlineFilePicker
 from textual.worker import Worker, WorkerState
 from loguru import logger
 import json
 import asyncio
 import re
 import html
+from pathlib import Path
 
 
 class DashboardScreen(Screen):
     """Main dashboard screen showing overview and stats."""
 
-    DEFAULT_ACTION_ID = "69295914ccbcd104b2e7446f"
+    DEFAULT_ACTION_ID = "69c2180355a89324a9926bc6"
 
     def __init__(self, *args, **kwargs):
         """Initialize the dashboard screen."""
@@ -28,6 +32,7 @@ class DashboardScreen(Screen):
         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
+        self._is_streaming: bool = False  # Track streaming state for send/stop toggle
 
     CSS = """
     DashboardScreen {
@@ -52,6 +57,13 @@ class DashboardScreen(Screen):
 
     .assistant-message {
         color: $text;
+        margin: 0;
+        padding: 0 1;
+    }
+
+    .assistant-message Markdown {
+        margin: 0;
+        padding: 0;
     }
 
     .error-message {
@@ -63,8 +75,14 @@ class DashboardScreen(Screen):
         text-style: italic;
     }
 
-    #input-bar {
+    #bottom-area {
         dock: bottom;
+        height: auto;
+        max-height: 24;
+        width: 100%;
+    }
+
+    #input-bar {
         height: 7;
         width: 100%;
         padding: 1 1 2 1;
@@ -108,6 +126,23 @@ class DashboardScreen(Screen):
         color: #00ffff;
     }
 
+    #slash-btn {
+        width: 5;
+        min-width: 5;
+        height: 3;
+        margin: 0 1 0 0;
+        background: #006666;
+        color: #00ffff;
+        border: solid #00d4d4;
+        text-align: center;
+        content-align: center middle;
+    }
+
+    #slash-btn:hover {
+        background: #008888;
+        color: #00ffff;
+    }
+
     #send-btn {
         width: 10;
         min-width: 10;
@@ -125,6 +160,16 @@ class DashboardScreen(Screen):
         color: #00ffff;
     }
 
+    #send-btn.streaming {
+        background: #660000;
+        color: #ff5555;
+        border: solid #ff5555;
+    }
+
+    #send-btn.streaming:hover {
+        background: #880000;
+    }
+
     .action-row {
         height: auto;
         width: 100%;
@@ -163,12 +208,15 @@ class DashboardScreen(Screen):
         with VerticalScroll(id="messages"):
             pass
 
-        with Vertical(id="input-bar"):
-            yield Static("", id="pending-files-bar")
-            with Horizontal(id="input-row"):
-                yield Button("+", id="upload-btn", variant="default")
-                yield ChatInput(placeholder="Message...", id="chat-input")
-                yield Button("Send", id="send-btn", variant="default")
+        with Vertical(id="bottom-area"):
+            yield InlineFilePicker(id="inline-file-picker")
+            with Vertical(id="input-bar"):
+                yield Static("", id="pending-files-bar")
+                with Horizontal(id="input-row"):
+                    yield Button("+", id="upload-btn", variant="default")
+                    yield Button("/", id="slash-btn", variant="default")
+                    yield ChatInput(placeholder="Message... (@ for files, / for commands)", id="chat-input")
+                    yield Button("Send", id="send-btn", variant="default")
 
         yield Footer()
 
@@ -176,6 +224,73 @@ class DashboardScreen(Screen):
         """Called when screen is mounted."""
         self.query_one("#chat-input", ChatInput).focus()
 
+    def on_chat_input_at_triggered(self, event: ChatInput.AtTriggered) -> None:
+        """Handle @ key — open inline file picker."""
+        chat_input = self.query_one("#chat-input", ChatInput)
+        picker = self.query_one("#inline-file-picker", InlineFilePicker)
+        chat_input.picker_active = True
+        picker.show_picker("")
+
+    def on_chat_input_at_filter_changed(self, event: ChatInput.AtFilterChanged) -> None:
+        """Update inline file picker filter."""
+        picker = self.query_one("#inline-file-picker", InlineFilePicker)
+        if picker.is_visible:
+            picker.filter(event.filter_text)
+
+    def on_chat_input_at_picker_navigate(self, event: ChatInput.AtPickerNavigate) -> None:
+        """Navigate inline file picker."""
+        picker = self.query_one("#inline-file-picker", InlineFilePicker)
+        if picker.is_visible:
+            picker.move_highlight(event.delta)
+
+    def on_chat_input_at_picker_select(self, event: ChatInput.AtPickerSelect) -> None:
+        """Select file from inline picker."""
+        picker = self.query_one("#inline-file-picker", InlineFilePicker)
+        if picker.is_visible:
+            picker.select_highlighted()
+
+    def on_chat_input_at_picker_cancel(self, event: ChatInput.AtPickerCancel) -> None:
+        """Cancel inline file picker."""
+        self._close_inline_picker()
+
+    def on_inline_file_picker_file_selected(self, event: InlineFilePicker.FileSelected) -> None:
+        """Handle file selection from inline picker — upload the file."""
+        self._close_inline_picker()
+        file_path = event.path
+        self._on_files_selected([file_path])
+
+    def on_inline_file_picker_cancelled(self, event: InlineFilePicker.Cancelled) -> None:
+        """Handle inline picker cancellation."""
+        self._close_inline_picker()
+
+    def _close_inline_picker(self) -> None:
+        """Close the inline file picker and clean up @ text from input."""
+        picker = self.query_one("#inline-file-picker", InlineFilePicker)
+        chat_input = self.query_one("#chat-input", ChatInput)
+        picker.hide_picker()
+        chat_input.picker_active = False
+        # Remove the @... text from the input
+        val = chat_input.value
+        at_pos = val.rfind("@")
+        if at_pos != -1:
+            chat_input.value = val[:at_pos]
+        chat_input.focus()
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        """Track text changes to update inline file picker filter."""
+        chat_input = self.query_one("#chat-input", ChatInput)
+        if not chat_input.picker_active:
+            return
+        val = event.value
+        at_pos = val.rfind("@")
+        if at_pos == -1:
+            # @ was deleted — close picker
+            self._close_inline_picker()
+            return
+        filter_text = val[at_pos + 1:]
+        picker = self.query_one("#inline-file-picker", InlineFilePicker)
+        picker.filter(filter_text)
+
     def on_input_submitted(self, event: Input.Submitted) -> None:
         """Handle message submission."""
         message = event.value.strip()
@@ -217,7 +332,8 @@ class DashboardScreen(Screen):
             success, urls, message = self.app.autobots_client.upload_files(args)
             if success:
                 self._pending_urls.extend(urls)
-                self.add_message(f"Uploaded {len(urls)} file(s). Attached to your next message.", "info")
+                uploaded_names = [Path(u.rsplit("/", 1)[-1]).name for u in urls]
+                self.add_message(f"Uploaded: {', '.join(uploaded_names)}. Attached to your next message.", "info")
                 self._update_pending_files_bar()
             else:
                 self.add_message(f"Upload failed: {message}", "error")
@@ -360,6 +476,8 @@ class DashboardScreen(Screen):
                 return
             self.current_run_id = run_id
             self.add_message("\n".join(["Continuing run:"] + lines), "info")
+            # Load conversation history
+            self._load_conversation_history(run_id)
             return
 
         if cmd == "/runtime":
@@ -656,10 +774,22 @@ class DashboardScreen(Screen):
         btn_id = event.button.id or ""
 
         if btn_id == "upload-btn":
-            self.app.push_screen(FileBrowserScreen(), callback=self._on_files_selected)
+            self.app.push_screen(AttachContentScreen(), callback=self._on_attach_result)
+            return
+
+        if btn_id == "slash-btn":
+            self.app.push_screen(SlashPickerScreen(), callback=self._on_slash_selected)
             return
 
         if btn_id == "send-btn":
+            if self._is_streaming:
+                # Stop: cancel active workers
+                for worker in self.workers:
+                    if not worker.is_finished:
+                        worker.cancel()
+                self._set_streaming(False)
+                self.add_message("Cancelled active request.", "info")
+                return
             chat_input = self.query_one("#chat-input", ChatInput)
             message = chat_input.value.strip()
             if not message:
@@ -709,6 +839,7 @@ class DashboardScreen(Screen):
                 return
             self.current_run_id = run_id
             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
@@ -726,25 +857,79 @@ class DashboardScreen(Screen):
 
         self.query_one("#chat-input", ChatInput).focus()
 
+    @staticmethod
+    def _prepare_markdown(text: str) -> str:
+        """Convert image markdown to links since terminals can't render images."""
+        return re.sub(r'!\[([^\]]*)\]\(([^)]+)\)', r'[\1](\2)', text)
+
     def add_message(self, text: str, msg_type: str = "assistant") -> None:
         """Add a message to the chat."""
         messages = self.query_one("#messages", VerticalScroll)
         css_class = f"message {msg_type}-message"
-        messages.mount(Static(text, classes=css_class))
+        if msg_type == "assistant":
+            widget = Markdown(self._prepare_markdown(text), classes=css_class)
+        else:
+            widget = Static(text, classes=css_class)
+        messages.mount(widget)
         messages.scroll_end(animate=False)
 
+    def _set_streaming(self, streaming: bool) -> None:
+        """Toggle the send button between Send and Stop states."""
+        self._is_streaming = streaming
+        send_btn = self.query_one("#send-btn", Button)
+        if streaming:
+            send_btn.label = "Stop"
+            send_btn.add_class("streaming")
+        else:
+            send_btn.label = "Send"
+            send_btn.remove_class("streaming")
+
+    def _on_attach_result(self, result: dict) -> None:
+        """Callback from AttachContentScreen."""
+        if not result:
+            self.query_one("#chat-input", ChatInput).focus()
+            return
+        if result.get("type") == "files":
+            self.app.push_screen(FileBrowserScreen(), callback=self._on_files_selected)
+        elif result.get("type") == "url":
+            url = result["url"]
+            self._pending_urls.append(url)
+            name = Path(url.rsplit("/", 1)[-1]).name if "/" in url else url
+            self.add_message(f"Attached: {name}", "info")
+            self._update_pending_files_bar()
+            self.query_one("#chat-input", ChatInput).focus()
+
+    def _on_slash_selected(self, command: str) -> None:
+        """Callback from SlashPickerScreen."""
+        if not command:
+            self.query_one("#chat-input", ChatInput).focus()
+            return
+        # Commands ending with space need args — insert into input
+        if command.endswith(" "):
+            chat_input = self.query_one("#chat-input", ChatInput)
+            chat_input.value = command
+            chat_input.cursor_position = len(command)
+            chat_input.focus()
+        else:
+            # No args needed — execute immediately
+            self.handle_slash_command(command)
+            self.query_one("#chat-input", ChatInput).focus()
+
     def _on_files_selected(self, file_paths: list[str]) -> None:
         """Callback from FileBrowserScreen — upload selected files."""
         if not file_paths:
+            self.query_one("#chat-input", ChatInput).focus()
             return
         if not hasattr(self.app, 'autobots_client'):
             self.add_message("Error: Client not initialized", "error")
             return
-        self.add_message(f"> Uploading {len(file_paths)} file(s)...", "user")
+        names = [Path(p).name for p in file_paths]
+        self.add_message(f"> Uploading: {', '.join(names)}", "user")
         success, urls, message = self.app.autobots_client.upload_files(file_paths)
         if success:
             self._pending_urls.extend(urls)
-            self.add_message(f"Uploaded {len(urls)} file(s). Attached to your next message.", "info")
+            uploaded_names = [Path(u.rsplit("/", 1)[-1]).name for u in urls]
+            self.add_message(f"Uploaded: {', '.join(uploaded_names)}. Attached to your next message.", "info")
             self._update_pending_files_bar()
         else:
             self.add_message(f"Upload failed: {message}", "error")
@@ -754,7 +939,6 @@ class DashboardScreen(Screen):
         """Update the pending-files bar to show queued file URLs or hide when empty."""
         bar = self.query_one("#pending-files-bar", Static)
         if self._pending_urls:
-            from pathlib import Path
             names = [Path(url.rsplit("/", 1)[-1]).name for url in self._pending_urls]
             bar.update(f"Attached: {', '.join(names)}")
         else:
@@ -771,37 +955,46 @@ class DashboardScreen(Screen):
 
     def run_action_with_polling(self, user_input: str) -> None:
         """Run action and stream results via SSE."""
+        # Kick off as a worker so the UI renders the user message first
+        self.run_worker(self._run_action_worker(user_input), exclusive=True, group="stream")
+
+    async def _run_action_worker(self, user_input: str) -> None:
+        """Async worker: send the action request then stream results."""
         client = self.app.autobots_client
 
-        # Send the message to the action
-        # If continuing a conversation, pass the current_run_id as action_result_id
         # Attach any pending file URLs and clear them
         urls = self._pending_urls.copy()
         self._pending_urls.clear()
         self._update_pending_files_bar()
 
-        success, run_id, message = client.run_action_async(
-            self.current_action_id,
-            user_input,
-            action_result_id=self.current_run_id,
-            urls=urls if urls else None,
-            metadata=self._metadata if self._metadata else None,
+        # Run the blocking HTTP call in a thread so the UI stays responsive
+        loop = asyncio.get_event_loop()
+        success, run_id, message = await loop.run_in_executor(
+            None,
+            lambda: client.run_action_async(
+                self.current_action_id,
+                user_input,
+                action_result_id=self.current_run_id,
+                urls=urls if urls else None,
+                metadata=self._metadata if self._metadata else None,
+            ),
         )
 
         if not success:
             self.add_message(f"Error starting action: {message}", "error")
             return
 
+        self._set_streaming(True)
+
         # Check if this is continuing an existing conversation
         if self.current_run_id and run_id == self.current_run_id:
             logger.info(f"Continuing conversation with run_id: {run_id}")
         else:
-            # New conversation started
             self.current_run_id = run_id
             logger.info(f"Started new conversation with run_id: {run_id}")
 
-        # exclusive=True cancels any previous stream worker entirely
-        self.run_worker(self.stream_results(run_id), exclusive=True, group="stream")
+        # Continue with streaming in the same worker
+        await self.stream_results(run_id)
 
     async def stream_results(self, run_id: str) -> None:
         """Stream action status and display final result from results array.
@@ -940,17 +1133,20 @@ class DashboardScreen(Screen):
                 status_task.cancel()
                 poll_task.cancel()
                 _remove_status_widget()
+                self._set_streaming(False)
                 return
             except asyncio.TimeoutError:
                 logger.warning(f"SSE timeout for {run_id}")
                 poll_task.cancel()
                 _remove_status_widget()
                 self.add_message("Action timed out waiting for response", "error")
+                self._set_streaming(False)
                 return
         except asyncio.CancelledError:
             logger.info(f"Stream worker cancelled for {run_id}")
             poll_task.cancel()
             _remove_status_widget()
+            self._set_streaming(False)
             return
         except Exception as e:
             logger.error(f"SSE error for {run_id}: {e}")
@@ -967,6 +1163,8 @@ class DashboardScreen(Screen):
         if not got_final_result:
             self.add_message("Could not get result. Use /new to start over.", "error")
 
+        self._set_streaming(False)
+
     def update_streaming_message(self, output: any, widget_ref: any = None) -> Static:
         """Update or create a streaming message widget with new output.
 
@@ -978,15 +1176,16 @@ class DashboardScreen(Screen):
 
         messages = self.query_one("#messages", VerticalScroll)
 
+        text_content = self._prepare_markdown(text_content)
         if widget_ref is None:
-            widget_ref = Static(text_content, classes="message assistant-message", markup=False, expand=True)
+            widget_ref = Markdown(text_content, classes="message assistant-message")
             messages.mount(widget_ref)
         else:
             try:
                 widget_ref.update(text_content)
             except Exception as e:
                 logger.warning(f"Failed to update widget: {e}")
-                widget_ref = Static(text_content, classes="message assistant-message", markup=False, expand=True)
+                widget_ref = Markdown(text_content, classes="message assistant-message")
                 messages.mount(widget_ref)
 
         messages.scroll_end(animate=False)
@@ -1033,6 +1232,47 @@ class DashboardScreen(Screen):
 
         return text.strip()
 
+    def _load_conversation_history(self, run_id: str) -> None:
+        """Load and display conversation history for a continued run."""
+        if not hasattr(self.app, 'autobots_client'):
+            logger.warning("No autobots_client, cannot load history")
+            return
+        success, result, msg = self.app.autobots_client.get_action_result(run_id)
+        logger.info(f"Load history: success={success}, msg={msg}")
+        if not success or not result:
+            return
+
+        logger.info(f"Result keys: {result.keys()}")
+        action_doc = result.get("result", {})
+        if not isinstance(action_doc, dict):
+            logger.warning(f"result['result'] is not a dict: {type(action_doc)}")
+            return
+        logger.info(f"ActionDoc keys: {action_doc.keys()}")
+        results_list = action_doc.get("results", [])
+        logger.info(f"results_list type={type(results_list)}, len={len(results_list) if isinstance(results_list, list) else 'N/A'}")
+        if not isinstance(results_list, list) or not results_list:
+            return
+
+        self.add_message("--- Conversation History ---", "info")
+        for i, item in enumerate(results_list):
+            if not isinstance(item, dict):
+                logger.warning(f"Result item {i} is not a dict: {type(item)}")
+                continue
+            logger.info(f"Result item {i} keys: {item.keys()}")
+            # Show user input
+            input_data = item.get("input")
+            if input_data:
+                input_text = self.extract_text_from_output(input_data) if isinstance(input_data, dict) else str(input_data)
+                if input_text:
+                    self.add_message(f"You: {input_text}", "user")
+            # Show assistant output
+            output_data = item.get("output")
+            if output_data:
+                output_text = self.extract_text_from_output(output_data) if isinstance(output_data, dict) else str(output_data)
+                if output_text:
+                    self.add_message(output_text, "assistant")
+        self.add_message("--- End of History ---", "info")
+
     def display_final_result(self, result: dict) -> None:
         """Display the final result from results array, showing only the latest output.
 

{kiwi_code-0.0.9 → kiwi_code-0.0.11}/src/kiwi_tui/screens/login.py

@@ -8,6 +8,8 @@ from textual.validation import Length
 from textual.message import Message
 from loguru import logger
 
+from pathlib import Path
+
 from kiwi_cli.models import LoginCredentials
 from kiwi_tui.widgets import ActionButton
 
@@ -45,21 +47,6 @@ class LoginScreen(Screen):
         width: auto;
     }
 
-    #logo-text-container {
-        margin-left: 2;
-        height: auto;
-    }
-
-    #logo-text {
-        color: #5fffff;
-        text-style: bold;
-        height: auto;
-    }
-
-    #logo-subtitle {
-        color: #5fffff;
-        height: auto;
-    }
 
     .divider {
         width: 100%;
@@ -157,22 +144,49 @@ class LoginScreen(Screen):
 
         with Container(id="login-container"):
             # Logo Section
-            with Horizontal(id="logo-container"):
-                logo_ascii = (
-                    "      #\n"
-                    "    #####\n"
-                    "  #########\n"
-                    " ###########\n"
-                    "#############\n"
-                    " ###########\n"
-                    "  #########\n"
-                    "    #####\n"
-                    "      #"
-                )
-                yield Static(logo_ascii, id="logo")
-                with Vertical(id="logo-text-container"):
-                    yield Static("KIWI AI", id="logo-text")
-                    yield Static("Terminal Agent for AI-Powered Automation", id="logo-subtitle")
+            with Vertical(id="logo-container"):
+                logo_lines = [
+                    "              ▄██▄              ",
+                    "              ████              ",
+                    "    ▄██▄▄     ████     ▄▄██▄    ",
+                    "    ▀█████▄   █▀▀█   ▄█████▀   ",
+                    "     ▀███▀▀█  ████  █▀▀███▀    ",
+                    "       ▀█▄  █ ████ █  ▄█▀      ",
+                    "          ▀▀▄██████▄▀▀         ",
+                    "▄██████▀▀█▄██████████▄█▀▀██████▄",
+                    "▀██████▄▄█▀██████████▀█▄▄██████▀",
+                    "          ▄▄▀██████▀▄▄         ",
+                    "       ▄█▀  █ ████ █  ▀█▄      ",
+                    "     ▄███▄▄█  ████  █▄▄███▄    ",
+                    "    ▄█████▀   █▄▄█   ▀█████▄   ",
+                    "    ▀██▀▀     ████     ▀▀██▀   ",
+                    "              ████              ",
+                    "              ▀██▀              ",
+                ]
+                text_lines = [
+                    "██╗  ██╗██╗██╗    ██╗██╗     █████╗ ██╗",
+                    "██║ ██╔╝██║██║    ██║██║    ██╔══██╗██║",
+                    "█████╔╝ ██║██║ █╗ ██║██║    ███████║██║",
+                    "██╔═██╗ ██║██║███╗██║██║    ██╔══██║██║",
+                    "██║  ██╗██║╚███╔███╔╝██║    ██║  ██║██║",
+                    "╚═╝  ╚═╝╚═╝ ╚══╝╚══╝ ╚═╝    ╚═╝  ╚═╝╚═╝",
+                ]
+                tagline = "Think fast. Code smarter. Automate everything."
+                gap = "  "
+                logo_w = 33
+                text_start = 5
+                banner_rows = []
+                for i, logo_line in enumerate(logo_lines):
+                    padded_logo = logo_line.ljust(logo_w)
+                    text_idx = i - text_start
+                    if 0 <= text_idx < len(text_lines):
+                        row = f"{padded_logo}{gap}{text_lines[text_idx]}"
+                    elif text_idx == len(text_lines) + 1:
+                        row = f"{padded_logo}{gap}{tagline}"
+                    else:
+                        row = padded_logo
+                    banner_rows.append(row)
+                yield Static("\n".join(banner_rows), id="logo")
 
             yield Static("", classes="divider")
 
@@ -185,6 +199,15 @@ class LoginScreen(Screen):
                 yield Static("> Mode:", classes="info-label")
                 yield Static("restricted", classes="info-value")
 
+            cwd = Path.cwd()
+            try:
+                display_path = "~" / cwd.relative_to(Path.home())
+            except ValueError:
+                display_path = cwd
+            with Horizontal(classes="info-row"):
+                yield Static("> Working Dir:", classes="info-label")
+                yield Static(str(display_path), classes="info-value")
+
             yield Static("Authentication", classes="section-header")
 
             with Horizontal(classes="form-group"):

kiwi_code-0.0.11/src/kiwi_tui/screens/slash_picker.py

@@ -0,0 +1,95 @@
+"""Slash command picker modal screen."""
+
+from textual.app import ComposeResult
+from textual.screen import ModalScreen
+from textual.widgets import Static, Button, OptionList
+from textual.widgets.option_list import Option
+from textual.containers import Vertical
+from textual.binding import Binding
+
+
+# Commands and their descriptions
+_COMMANDS = [
+    ("/help", "Show help"),
+    ("/new", "Start new conversation"),
+    ("/status", "Show current action & run"),
+    ("/cancel", "Cancel active request"),
+    ("/actions list", "List recent actions"),
+    ("/runs list", "List recent runs"),
+    ("/graphs list", "List recent graphs"),
+    ("/graph-runs list", "List recent graph runs"),
+    ("/use ", "Switch action by ID"),
+    ("/continue ", "Continue a run by ID"),
+    ("/upload ", "Upload file(s) by path"),
+    ("/files", "Show pending files"),
+    ("/clear-files", "Clear pending files"),
+    ("/login", "Log in"),
+    ("/logout", "Log out"),
+    ("/metadata", "Show metadata"),
+    ("/metadata set ", "Set metadata key"),
+    ("/metadata remove ", "Remove metadata key"),
+    ("/metadata clear", "Clear all metadata"),
+    ("/runtime status", "Runtime status"),
+    ("/runtime start", "Start runtime"),
+    ("/runtime stop", "Stop runtime"),
+    ("/runtime restart", "Restart runtime"),
+    ("/runtime list", "List all runtimes"),
+    ("/runtime logs", "Show runtime logs"),
+]
+
+
+class SlashPickerScreen(ModalScreen[str]):
+    """Modal that lets the user pick a slash command.
+
+    Returns the command string, or empty string if cancelled.
+    Commands that don't need arguments (no trailing space) are returned as-is
+    for immediate execution.
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=True),
+    ]
+
+    CSS = """
+    SlashPickerScreen {
+        align: center middle;
+    }
+
+    #slash-container {
+        width: 70;
+        height: 80%;
+        background: $surface;
+        border: solid #00d4d4;
+        padding: 1 2;
+    }
+
+    #slash-title {
+        width: 100%;
+        text-align: center;
+        text-style: bold;
+        color: #00ffff;
+        height: 1;
+        margin-bottom: 1;
+    }
+
+    #slash-list {
+        height: 1fr;
+        width: 100%;
+        border: solid #444444;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="slash-container"):
+            yield Static("Select a command", id="slash-title")
+            option_list = OptionList(id="slash-list")
+            for cmd, desc in _COMMANDS:
+                option_list.add_option(Option(f"{cmd:<25} {desc}", id=cmd))
+            yield option_list
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        cmd = event.option.id or ""
+        self.dismiss(cmd)
+
+    def action_cancel(self) -> None:
+        self.dismiss("")

{kiwi_code-0.0.9 → kiwi_code-0.0.11}/src/kiwi_tui/widgets.py

@@ -5,6 +5,7 @@ from textual.containers import Container, Vertical, Horizontal
 from textual.widgets import Static, Button, Label, DataTable, Input
 from textual.reactive import reactive
 from textual.suggester import SuggestFromList
+from textual.message import Message
 from rich.text import Text
 
 
@@ -43,16 +44,41 @@ _SLASH_COMMANDS = [
 
 
 class ChatInput(Input):
-    """Input with command history (up/down arrows) and slash command autocomplete."""
+    """Input with command history (up/down arrows), slash command autocomplete, and @ file picker."""
 
     _MAX_HISTORY = 200
 
+    class AtTriggered(Message):
+        """Posted when user types @ to open inline file picker."""
+        pass
+
+    class AtFilterChanged(Message):
+        """Posted when the filter text after @ changes."""
+        def __init__(self, filter_text: str) -> None:
+            super().__init__()
+            self.filter_text = filter_text
+
+    class AtPickerNavigate(Message):
+        """Posted when user presses up/down while picker is open."""
+        def __init__(self, delta: int) -> None:
+            super().__init__()
+            self.delta = delta
+
+    class AtPickerSelect(Message):
+        """Posted when user presses Enter while picker is open."""
+        pass
+
+    class AtPickerCancel(Message):
+        """Posted when user presses Escape while picker is open."""
+        pass
+
     def __init__(self, *args, **kwargs):
         kwargs.setdefault("suggester", SuggestFromList(_SLASH_COMMANDS, case_sensitive=False))
         super().__init__(*args, **kwargs)
         self._history: list[str] = []
         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
 
     def record(self, value: str) -> None:
         """Add a submitted value to history."""
@@ -68,8 +94,54 @@ class ChatInput(Input):
         self._history_index = -1
         self._draft = ""
 
+    def _get_at_filter(self) -> str | None:
+        """Extract filter text after the last '@' if picker is active."""
+        if not self.picker_active:
+            return None
+        val = self.value
+        at_pos = val.rfind("@")
+        if at_pos == -1:
+            return None
+        return val[at_pos + 1:]
+
     async def _on_key(self, event) -> None:
-        if event.key == "up":
+        if self.picker_active:
+            # While picker is open, intercept navigation keys
+            if event.key == "up":
+                event.prevent_default()
+                event.stop()
+                self.post_message(self.AtPickerNavigate(-1))
+                return
+            elif event.key == "down":
+                event.prevent_default()
+                event.stop()
+                self.post_message(self.AtPickerNavigate(1))
+                return
+            elif event.key == "enter":
+                event.prevent_default()
+                event.stop()
+                self.post_message(self.AtPickerSelect())
+                return
+            elif event.key == "escape":
+                event.prevent_default()
+                event.stop()
+                self.post_message(self.AtPickerCancel())
+                return
+            elif event.key == "tab":
+                event.prevent_default()
+                event.stop()
+                self.post_message(self.AtPickerSelect())
+                return
+            # For other keys (typing), let them through and we'll update filter via on_changed
+            await super()._on_key(event)
+            return
+
+        if event.key == "at_sign" or event.character == "@":
+            # Let @ be typed into the input, then trigger the picker
+            await super()._on_key(event)
+            self.post_message(self.AtTriggered())
+            return
+        elif event.key == "up":
             if not self._history:
                 return
             event.prevent_default()

{kiwi_code-0.0.9 → kiwi_code-0.0.11}/uv.lock

@@ -319,7 +319,7 @@ wheels = [
 
 [[package]]
 name = "kiwi-code"
-version = "0.0.9"
+version = "0.0.11"
 source = { editable = "." }
 dependencies = [
     { name = "autobots-client" },