lang2sim 2.0.0__py3-none-any.whl

lang2sim/cli/app.py

@@ -0,0 +1,183 @@
+"""
+Main Textual Application for Lang2Sim
+File: lang2sim/cli/app.py
+"""
+
+from pathlib import Path
+from textual.app import App
+from textual.binding import Binding
+from .screens.landing_screen import LandingScreen
+
+CSS_PATH = Path(__file__).parent / "styles" / "app.tcss"
+
+class Lang2SimApp(App):
+    """Lang2Sim Terminal Copilot Application."""
+
+    TITLE = "lang2sim — lang2sim"
+    CSS_PATH = CSS_PATH
+
+    BINDINGS = [
+        Binding("ctrl+a", "select_all", "Select All", show=False),
+        Binding("ctrl+c", "copy_or_quit", "Copy / Quit", show=False),
+        Binding("ctrl+shift+c", "copy_selection", "Copy Selection", show=False),
+        Binding("shift+ctrl+c", "copy_selection", "Copy Selection", show=False),
+        Binding("ctrl+y", "copy_selection", "Copy Selection", show=False),
+        Binding("ctrl+p", "command_palette", "Command Palette", show=False),
+        Binding("ctrl+s", "open_sessions", "Sessions", show=False),
+        Binding("ctrl+n", "new_session", "New Session", show=False),
+    ]
+
+    def action_select_all(self) -> None:
+        """Selects all text in focused input or selects the entire conversation for copying."""
+        if hasattr(self.screen, "action_select_all"):
+            self.screen.action_select_all()
+        else:
+            focused = self.screen.focused
+            if focused is not None and hasattr(focused, "action_select_all"):
+                focused.action_select_all()
+
+    def action_copy_selection(self) -> None:
+        """Copies currently selected text or entire conversation to system clipboard via OSC 52."""
+        import base64
+        import sys
+        from pathlib import Path
+
+        text = ""
+        if hasattr(self.screen, "_selected_text") and self.screen._selected_text:
+            text = self.screen._selected_text
+        elif hasattr(self.screen, "get_selected_text"):
+            text = self.screen.get_selected_text() or ""
+
+        if not text:
+            focused = self.screen.focused
+            if focused is not None:
+                if hasattr(focused, "selected_text") and focused.selected_text:
+                    text = focused.selected_text
+                elif hasattr(focused, "value") and focused.value:
+                    text = focused.value
+                elif hasattr(focused, "text") and focused.text:
+                    text = focused.text
+
+        # Fallback: copy full conversation if nothing was specifically selected
+        if not text and hasattr(self.screen, "get_conversation_as_text"):
+            text = self.screen.get_conversation_as_text()
+
+        if text:
+            import subprocess
+            import shutil
+
+            # 1. Native Wayland clipboard (wl-copy) for Ubuntu Wayland sessions
+            wl_copy = shutil.which("wl-copy") or str(Path.home() / ".local" / "bin" / "wl-copy")
+            try:
+                env = os.environ.copy()
+                if "WAYLAND_DISPLAY" not in env:
+                    env["WAYLAND_DISPLAY"] = "wayland-0"
+                p = subprocess.Popen([wl_copy], stdin=subprocess.PIPE, env=env)
+                p.communicate(input=text.encode("utf-8"), timeout=1.0)
+            except Exception:
+                pass
+
+            # 2. Native X11 clipboard via xclip (for Xwayland / X11 apps)
+            xclip = shutil.which("xclip") or str(Path.home() / ".local" / "bin" / "xclip")
+            try:
+                for sel in ["clipboard", "primary"]:
+                    p = subprocess.Popen([xclip, "-selection", sel], stdin=subprocess.PIPE)
+                    p.communicate(input=text.encode("utf-8"), timeout=1.0)
+            except Exception:
+                pass
+
+            # 3. Textual native clipboard
+            try:
+                self.copy_to_clipboard(text)
+            except Exception:
+                pass
+
+            # 4. Direct OSC 52 terminal clipboard escape sequence
+            try:
+                b64 = base64.b64encode(text.encode("utf-8")).decode("ascii")
+                sys.stdout.write(f"\033]52;c;{b64}\007")
+                sys.stdout.flush()
+            except Exception:
+                pass
+
+            # 5. File export for zero-friction copy/paste
+            try:
+                export_path = Path.home() / ".lang2sim" / "clipboard_export.txt"
+                export_path.parent.mkdir(parents=True, exist_ok=True)
+                export_path.write_text(text, encoding="utf-8")
+            except Exception:
+                pass
+
+            self.notify(f"Copied {len(text)} characters to clipboard!", title="Clipboard", timeout=2.0)
+
+    def action_copy_or_quit(self) -> None:
+        """Copies selected text if any exists, otherwise exits."""
+        text = ""
+        if hasattr(self.screen, "_selected_text") and self.screen._selected_text:
+            text = self.screen._selected_text
+        elif hasattr(self.screen, "get_selected_text"):
+            text = self.screen.get_selected_text() or ""
+        if not text:
+            focused = self.screen.focused
+            if focused is not None and hasattr(focused, "selected_text") and focused.selected_text:
+                text = focused.selected_text
+
+        if text:
+            self.action_copy_selection()
+        else:
+            self.exit()
+
+    def on_mount(self) -> None:
+        """Mount initial landing screen."""
+        self.push_screen(LandingScreen())
+
+    def action_command_palette(self) -> None:
+        """Open custom floating command palette modal."""
+        from .screens.command_palette_modal import CommandPaletteModal
+        self.push_screen(CommandPaletteModal(), callback=self.on_command_palette_result)
+
+    def action_open_sessions(self) -> None:
+        """Open custom floating sessions modal."""
+        from .screens.sessions_modal import SessionsModal
+        self.push_screen(SessionsModal(), callback=self.on_session_selected)
+
+    def action_new_session(self) -> None:
+        """Create new blank session and navigate to Workspace."""
+        from .screens.workspace_screen import WorkspaceScreen
+        self.switch_screen(WorkspaceScreen(session_id=None))
+
+    def on_session_selected(self, session_id: str | None) -> None:
+        if not session_id:
+            return
+        from .screens.workspace_screen import WorkspaceScreen
+        if isinstance(self.screen, WorkspaceScreen):
+            self.screen.load_session(session_id)
+        else:
+            self.switch_screen(WorkspaceScreen(session_id=session_id))
+
+    def on_command_palette_result(self, result: str | None) -> None:
+        if not result:
+            return
+        if result in ("switch_session", "switch_session_all"):
+            self.call_after_refresh(self.action_open_sessions)
+        elif result == "new_session":
+            self.call_after_refresh(self.action_new_session)
+        elif result in ("switch_model", "switch_model_agent"):
+            self.notify("Model: NVIDIA Nemotron 3 Ultra 550B active", title="Model")
+        elif result in ("run_doctor", "sim_doctor"):
+            self.notify("All systems nominal: GPU, Display, and Docker ready", title="Doctor")
+        elif result == "toggle_headless":
+            self.notify("Headless mode toggled", title="Runtime")
+        elif result == "connect_stream":
+            self.notify("Foxglove stream available at ws://127.0.0.1:8765", title="Stream")
+        elif result == "reset_sim":
+            self.notify("Emergency world reset dispatched", title="Simulation")
+
+
+def main():
+    """Console script entrypoint: lang2sim."""
+    app = Lang2SimApp()
+    app.run()
+
+if __name__ == "__main__":
+    main()

lang2sim/cli/screens/__init__.py

@@ -0,0 +1,8 @@
+from .landing_screen import LandingScreen
+from .workspace_screen import WorkspaceScreen
+from .command_palette_modal import CommandPaletteModal
+from .sessions_modal import SessionsModal
+
+__all__ = ["LandingScreen", "WorkspaceScreen", "CommandPaletteModal", "SessionsModal"]
+
+

lang2sim/cli/screens/command_palette_modal.py

@@ -0,0 +1,146 @@
+"""
+Custom Command Palette Modal (ctrl+p)
+File: lang2sim/cli/screens/command_palette_modal.py
+"""
+
+from typing import List, Dict, Optional
+from textual.screen import ModalScreen
+from textual.widgets import Input, Static
+from textual.containers import Vertical, Horizontal, VerticalScroll
+from textual.binding import Binding
+
+
+COMMANDS: List[Dict[str, str]] = [
+    # Suggested
+    {"id": "switch_session", "category": "Suggested", "title": "Switch session", "shortcut": "ctrl+x l"},
+    {"id": "switch_model", "category": "Suggested", "title": "Switch model", "shortcut": "ctrl+x m"},
+    {"id": "run_doctor", "category": "Suggested", "title": "Run simulation doctor", "shortcut": "ctrl+x d"},
+
+    # Session
+    {"id": "switch_session_all", "category": "Session", "title": "Switch session", "shortcut": "ctrl+x l"},
+    {"id": "new_session", "category": "Session", "title": "New session", "shortcut": "ctrl+x n"},
+    {"id": "open_editor", "category": "Session", "title": "Open editor", "shortcut": "ctrl+x e"},
+    {"id": "move_session", "category": "Session", "title": "Move session", "description": "Move to another project dir", "shortcut": ""},
+
+    # Agent
+    {"id": "switch_model_agent", "category": "Agent", "title": "Switch model", "shortcut": "ctrl+x m"},
+    {"id": "switch_agent", "category": "Agent", "title": "Switch agent", "shortcut": "ctrl+x a"},
+    {"id": "toggle_mcps", "category": "Agent", "title": "Toggle MCPs", "shortcut": ""},
+    {"id": "variant_cycle", "category": "Agent", "title": "Variant cycle", "shortcut": "ctrl+t"},
+    {"id": "switch_variant", "category": "Agent", "title": "Switch model variant", "shortcut": ""},
+
+    # Runtime & Display
+    {"id": "sim_doctor", "category": "Runtime", "title": "Run doctor diagnostic", "shortcut": "ctrl+x d"},
+    {"id": "toggle_headless", "category": "Runtime", "title": "Toggle headless mode", "shortcut": "ctrl+x h"},
+    {"id": "connect_stream", "category": "Runtime", "title": "Connect Foxglove / noVNC", "shortcut": "ctrl+x f"},
+    {"id": "reset_sim", "category": "Runtime", "title": "Emergency reset world", "shortcut": "ctrl+x r"},
+
+    # Provider
+    {"id": "connect_provider", "category": "Provider", "title": "Connect provider", "shortcut": ""},
+]
+
+
+class CommandPaletteModal(ModalScreen[Optional[str]]):
+    """Floating Command Palette Modal matching OpenCode UI."""
+
+    BINDINGS = [
+        Binding("escape", "dismiss_modal", "Close", show=False),
+        Binding("up", "cursor_up", "Up", show=False),
+        Binding("down", "cursor_down", "Down", show=False),
+        Binding("enter", "submit_selected", "Select", show=False),
+    ]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.selected_index: int = 0
+        self.filtered_commands: List[Dict[str, str]] = list(COMMANDS)
+
+    def compose(self):
+        with Vertical(id="command-palette-dialog"):
+            with Horizontal(id="palette-header"):
+                yield Static("Commands", id="palette-title")
+                yield Static("esc", id="palette-esc")
+
+            yield Input(placeholder="Search", id="palette-search")
+            yield VerticalScroll(id="palette-list")
+
+    async def on_mount(self) -> None:
+        self.query_one(Input).focus()
+        await self.rebuild_list()
+
+    async def on_input_changed(self, event: Input.Changed) -> None:
+        query = event.value.strip().lower()
+        if not query:
+            self.filtered_commands = list(COMMANDS)
+        else:
+            self.filtered_commands = [
+                cmd for cmd in COMMANDS
+                if query in cmd["title"].lower()
+                or query in cmd["category"].lower()
+                or query in cmd.get("description", "").lower()
+            ]
+        self.selected_index = 0
+        await self.rebuild_list()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self.action_submit_selected()
+
+    async def rebuild_list(self) -> None:
+        list_container = self.query_one("#palette-list", VerticalScroll)
+        await list_container.remove_children()
+
+        if not self.filtered_commands:
+            await list_container.mount(Static("[#6b7280]No matching commands[/]", classes="palette-empty"))
+            return
+
+        current_category = None
+        current_item_idx = 0
+
+        for cmd in self.filtered_commands:
+            cat = cmd["category"]
+            if cat != current_category:
+                current_category = cat
+                await list_container.mount(Static(cat, classes="palette-category"))
+
+            is_selected = (current_item_idx == self.selected_index)
+            item_classes = "palette-item -selected" if is_selected else "palette-item"
+
+            title_text = cmd["title"]
+            if cmd.get("description"):
+                title_text += f" [#6b7280]{cmd['description']}[/]"
+
+            children = [Static(title_text, classes="palette-item-title")]
+            if cmd.get("shortcut"):
+                children.append(Static(cmd["shortcut"], classes="palette-shortcut"))
+
+            row = Horizontal(*children, classes=item_classes)
+            await list_container.mount(row)
+
+            current_item_idx += 1
+
+    def update_selection(self) -> None:
+        rows = list(self.query("#palette-list .palette-item"))
+        for idx, row in enumerate(rows):
+            row.set_class(idx == self.selected_index, "-selected")
+        if 0 <= self.selected_index < len(rows):
+            rows[self.selected_index].scroll_visible(animate=False)
+
+    def action_cursor_up(self) -> None:
+        if self.filtered_commands and self.selected_index > 0:
+            self.selected_index -= 1
+            self.update_selection()
+
+    def action_cursor_down(self) -> None:
+        if self.filtered_commands and self.selected_index < len(self.filtered_commands) - 1:
+            self.selected_index += 1
+            self.update_selection()
+
+    def action_submit_selected(self) -> None:
+        if self.filtered_commands and 0 <= self.selected_index < len(self.filtered_commands):
+            cmd = self.filtered_commands[self.selected_index]
+            self.dismiss(cmd["id"])
+        else:
+            self.dismiss(None)
+
+    def action_dismiss_modal(self) -> None:
+        self.dismiss(None)

lang2sim/cli/screens/landing_screen.py

@@ -0,0 +1,96 @@
+"""
+Screen 1: Landing Screen
+File: lang2sim/cli/screens/landing_screen.py
+"""
+
+from textual.screen import Screen
+from textual.widgets import Static
+from textual.containers import Vertical, Center, Horizontal
+from ..widgets.prompt_card import PromptCard
+
+# ── Logo: pixel-bitmap glyphs rendered with half-blocks (2 pixel rows per text row) ──
+GLYPHS = {
+    "l": ["##", "##", "##", "##", "##", "##", "..", ".."],
+    "a": ["......", "......", "######", "....##", "######", "######", "......", "......"],
+    "n": ["......", "......", "######", "##..##", "##..##", "##..##", "......", "......"],
+    "g": ["......", "......", "######", "##..##", "######", "....##", "....##", "######"],
+    "2": ["######", "....##", "######", "##....", "##....", "######", "......", "......"],
+    "s": ["......", "......", "######", "##....", "....##", "######", "......", "......"],
+    "i": ["##", "..", "##", "##", "##", "##", "..", ".."],
+    "m": ["..........", "..........", "##########", "##..##..##",
+          "##..##..##", "##..##..##", "..........", ".........."],
+}
+
+# Left-to-right fade: dark gray -> white (one shade per letter)
+COLORS = {
+    "l": "#6b7280",
+    "a": "#80858f",
+    "n": "#979ca6",
+    "g": "#adb2ba",
+    "2": "#c8ccd2",
+    "s": "#dfe1e5",
+    "i": "#f1f2f4",
+    "m": "#ffffff",
+}
+
+# (top pixel, bottom pixel) -> half-block character
+HALF = {(0, 0): " ", (1, 0): "▀", (0, 1): "▄", (1, 1): "█"}
+
+
+def build_logo(word: str = "lang2sim", gap: int = 1) -> str:
+    """Render glyph bitmaps as 4 text rows with per-letter Rich color tags."""
+    rows = []
+    for r in range(0, 8, 2):
+        line = ""
+        for idx, ch in enumerate(word):
+            g = GLYPHS[ch]
+            seg = "".join(
+                HALF[(int(g[r][x] == "#"), int(g[r + 1][x] == "#"))]
+                for x in range(len(g[0]))
+            )
+            line += f"[{COLORS[ch]}]{seg}[/]"
+            if idx < len(word) - 1:
+                line += " " * gap
+        rows.append(line)
+    return "\n".join(rows)
+
+
+LOGO_TEXT = build_logo()
+
+
+class LandingScreen(Screen):
+    """The initial landing screen matching the reference image."""
+
+    def compose(self):
+        with Center(id="landing-container"):
+            with Vertical(id="landing-inner"):
+                yield Static(LOGO_TEXT, id="landing-logo")
+                yield PromptCard(
+                    placeholder="Ask anything.. 'Spawn 14x10m warehouse with 8 racks, send AMR to rack 5'",
+                    card_id="landing-prompt-input",
+                    id="landing-card",
+                )
+                with Horizontal(id="shortcuts-container"):
+                    yield Static(
+                        "[#6b7280]tab[/] [#9ca3af]agents[/]   [#6b7280]ctrl+p[/] [#9ca3af]commands[/]",
+                        id="landing-shortcuts",
+                    )
+                with Center():
+                    yield Static(
+                        "[#f59e0b]●[/] [bold #f3f4f6]Tip[/] [#9ca3af]Press[/] "
+                        "[bold #ffffff]shift+enter[/] [#9ca3af]to add newlines in your prompt[/]",
+                        id="landing-tip",
+                    )
+
+        with Horizontal(id="workspace-footer"):
+            yield Static("~", classes="footer-left")
+            yield Static("", classes="footer-spacer")
+            yield Static("[#6b7280]lang2sim 2.0.0[/]", classes="footer-right")
+
+    def on_mount(self) -> None:
+        self.query_one(PromptCard).focus_input()
+
+    def on_prompt_card_submitted(self, message: PromptCard.Submitted) -> None:
+        """When user submits a prompt, transition to WorkspaceScreen."""
+        from .workspace_screen import WorkspaceScreen
+        self.app.switch_screen(WorkspaceScreen(initial_prompt=message.value))

lang2sim/cli/screens/sessions_modal.py

@@ -0,0 +1,236 @@
+"""
+Sessions Modal (ctrl+s / Command Palette)
+File: lang2sim/cli/screens/sessions_modal.py
+"""
+
+from typing import List, Dict, Optional
+from textual.screen import ModalScreen
+from textual.widgets import Static, Input
+from textual.containers import Vertical, Horizontal, VerticalScroll
+from textual.binding import Binding
+from ...core.session_manager import session_manager, ChatSession
+
+
+class RenameModal(ModalScreen[Optional[str]]):
+    """Small popup modal to rename a session."""
+
+    DEFAULT_CSS = """
+    RenameModal {
+        align: center middle;
+        background: rgba(0, 0, 0, 0.75);
+    }
+
+    #rename-dialog {
+        width: 50;
+        height: auto;
+        background: #161618;
+        border: solid #27272a;
+        padding: 1 2;
+    }
+
+    #rename-title {
+        color: #ffffff;
+        text-style: bold;
+        margin-bottom: 1;
+    }
+
+    #rename-input {
+        background: #09090b;
+        border: solid #3f3f46;
+        color: #ffffff;
+    }
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel"),
+    ]
+
+    def __init__(self, current_title: str, **kwargs):
+        super().__init__(**kwargs)
+        self.current_title = current_title
+
+    def compose(self):
+        with Vertical(id="rename-dialog"):
+            yield Static("Rename Session", id="rename-title")
+            yield Input(value=self.current_title, id="rename-input")
+
+    def on_mount(self) -> None:
+        inp = self.query_one("#rename-input", Input)
+        inp.focus()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        val = event.value.strip()
+        self.dismiss(val if val else None)
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+class SessionsModal(ModalScreen[Optional[str]]):
+    """Modal dialog displaying grouped chat sessions with search, pin, delete, and rename."""
+
+    BINDINGS = [
+        Binding("escape", "dismiss_modal", "Dismiss", show=False),
+        Binding("up", "cursor_up", "Cursor Up", show=False),
+        Binding("down", "cursor_down", "Cursor Down", show=False),
+        Binding("enter", "submit_selected", "Open Session", show=False),
+        Binding("ctrl+f", "toggle_pin", "Pin/Unpin", show=False),
+        Binding("ctrl+d", "delete_selected", "Delete", show=False),
+        Binding("ctrl+r", "rename_selected", "Rename", show=False),
+    ]
+
+    def __init__(self, workspace_name: Optional[str] = None, **kwargs):
+        super().__init__(**kwargs)
+        self.workspace_name = workspace_name
+        self.all_sessions: List[ChatSession] = []
+        self.filtered_sessions: List[ChatSession] = []
+        self.selected_index: int = 0
+
+    def compose(self):
+        with Vertical(id="sessions-dialog"):
+            # Header: Sessions | esc
+            with Horizontal(id="sessions-header"):
+                yield Static("Sessions", id="sessions-title")
+                yield Static("", classes="header-spacer")
+                yield Static("esc", id="sessions-esc")
+
+            # Search bar
+            yield Input(placeholder="Search", id="sessions-search")
+
+            # Sessions list container
+            with VerticalScroll(id="sessions-list"):
+                yield Static("", id="sessions-list-anchor")
+
+            # Footer actions bar
+            with Horizontal(id="sessions-footer"):
+                yield Static(
+                    "pin/unpin [bold #9ca3af]ctrl+f[/]   delete [bold #9ca3af]ctrl+d[/]   rename [bold #9ca3af]ctrl+r[/]",
+                    id="sessions-footer-actions",
+                )
+
+    async def on_mount(self) -> None:
+        self.load_and_refresh()
+        self.query_one("#sessions-search", Input).focus()
+
+    def load_and_refresh(self) -> None:
+        self.all_sessions = session_manager.list_sessions(self.workspace_name)
+        search_query = ""
+        try:
+            search_query = self.query_one("#sessions-search", Input).value.strip().lower()
+        except Exception:
+            pass
+        self.filter_sessions(search_query)
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id == "sessions-search":
+            self.filter_sessions(event.value.strip().lower())
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "sessions-search":
+            self.action_submit_selected()
+
+
+    def filter_sessions(self, query: str) -> None:
+        if not query:
+            self.filtered_sessions = list(self.all_sessions)
+        else:
+            self.filtered_sessions = [
+                s for s in self.all_sessions if query in s.title.lower()
+            ]
+
+        if self.selected_index >= len(self.filtered_sessions):
+            self.selected_index = max(0, len(self.filtered_sessions) - 1)
+
+        self.run_worker(self.rebuild_list())
+
+    async def rebuild_list(self) -> None:
+        list_container = self.query_one("#sessions-list", VerticalScroll)
+        await list_container.remove_children()
+
+        if not self.filtered_sessions:
+            row = Horizontal(
+                Static("[#71717a]No matching sessions found[/]", classes="session-empty")
+            )
+            await list_container.mount(row)
+            return
+
+        grouped = session_manager.group_sessions_by_date(self.filtered_sessions)
+        current_item_idx = 0
+
+        for header, sessions in grouped.items():
+            # Date group header (lavender)
+            header_row = Horizontal(
+                Static(f"[bold #a78bfa]{header}[/]", classes="session-group-header")
+            )
+            await list_container.mount(header_row)
+
+            for s in sessions:
+                is_selected = (current_item_idx == self.selected_index)
+                item_classes = "session-item -selected" if is_selected else "session-item"
+                bullet = "● " if is_selected else "  "
+                title_text = s.title
+
+                row = Horizontal(
+                    Static(f"{bullet}{title_text}", classes="session-item-text"),
+                    classes=item_classes,
+                )
+                await list_container.mount(row)
+                current_item_idx += 1
+
+    def update_selection(self) -> None:
+        rows = list(self.query("#sessions-list .session-item"))
+        for idx, row in enumerate(rows):
+            is_selected = (idx == self.selected_index)
+            row.set_class(is_selected, "-selected")
+            try:
+                txt_widget = row.query_one(".session-item-text", Static)
+                raw_text = self.filtered_sessions[idx].title
+                bullet = "● " if is_selected else "  "
+                txt_widget.update(f"{bullet}{raw_text}")
+            except Exception:
+                pass
+        if 0 <= self.selected_index < len(rows):
+            rows[self.selected_index].scroll_visible(animate=False)
+
+    def action_cursor_up(self) -> None:
+        if self.filtered_sessions and self.selected_index > 0:
+            self.selected_index -= 1
+            self.update_selection()
+
+    def action_cursor_down(self) -> None:
+        if self.filtered_sessions and self.selected_index < len(self.filtered_sessions) - 1:
+            self.selected_index += 1
+            self.update_selection()
+
+    def action_submit_selected(self) -> None:
+        if self.filtered_sessions and 0 <= self.selected_index < len(self.filtered_sessions):
+            chosen = self.filtered_sessions[self.selected_index]
+            self.dismiss(chosen.id)
+        else:
+            self.dismiss(None)
+
+    def action_toggle_pin(self) -> None:
+        if self.filtered_sessions and 0 <= self.selected_index < len(self.filtered_sessions):
+            target = self.filtered_sessions[self.selected_index]
+            session_manager.pin_session(target.id)
+            self.load_and_refresh()
+
+    def action_delete_selected(self) -> None:
+        if self.filtered_sessions and 0 <= self.selected_index < len(self.filtered_sessions):
+            target = self.filtered_sessions[self.selected_index]
+            session_manager.delete_session(target.id)
+            self.load_and_refresh()
+
+    def action_rename_selected(self) -> None:
+        if self.filtered_sessions and 0 <= self.selected_index < len(self.filtered_sessions):
+            target = self.filtered_sessions[self.selected_index]
+
+            def on_renamed(new_name: Optional[str]) -> None:
+                if new_name:
+                    session_manager.rename_session(target.id, new_name)
+                    self.load_and_refresh()
+
+            self.app.push_screen(RenameModal(current_title=target.title), callback=on_renamed)
+
+    def action_dismiss_modal(self) -> None:
+        self.dismiss(None)