stcode 0.0.1a0__py3-none-any.whl

stcode/cli/ui/screens/connect.py

@@ -0,0 +1,126 @@
+"""
+Connect screen — point this client at a daemon.
+
+`--daemonless` is what this exists for: the agent runs somewhere else, and this terminal
+is only a window onto it. Nothing starts here, so a failed connection is a question —
+*which daemon?* — rather than an error.
+
+It returns an `Address` and nothing else, and switching transport swaps which pair of
+fields is shown rather than offering four of which two are ignored.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import ClassVar
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import BindingType
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label, Select, Static
+
+from stcode.cli import labels
+from stcode.cli.services.client import Address
+
+
+class ConnectScreen(ModalScreen[Address | None]):
+    """Ask where the daemon is."""
+
+    BINDINGS: ClassVar[list[BindingType]] = [("escape", "cancel", "Cancel")]
+
+    CSS_PATH = "connect.tcss"
+
+    def __init__(self, settings: Address, *, reason: str = "") -> None:
+        super().__init__()
+        self._settings = settings
+        self._reason = reason
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="connect-dialog"):
+            yield Static(labels.CONNECT_TITLE, id="connect-title")
+            yield Static(self._reason or labels.CONNECT_INTRO, id="connect-intro")
+
+            yield Label(labels.FIELD_TRANSPORT, classes="field-label")
+            yield Select(
+                labels.transport_options(),
+                value=self._settings.transport,
+                allow_blank=False,
+                id="transport",
+            )
+
+            yield Label(labels.FIELD_SOCKET, classes="field-label", id="socket-label")
+            yield Input(value=str(self._settings.socket), id="socket")
+
+            yield Label(labels.FIELD_HOST, classes="field-label", id="host-label")
+            yield Input(
+                value=self._settings.host,
+                placeholder=labels.HOST_PLACEHOLDER,
+                id="host",
+            )
+
+            yield Label(labels.FIELD_PORT, classes="field-label", id="port-label")
+            yield Input(value=str(self._settings.port), id="port")
+
+            with Horizontal(id="connect-buttons"):
+                yield Button(labels.BUTTON_CANCEL, id="cancel")
+                yield Button(labels.BUTTON_CONNECT, variant="primary", id="connect")
+
+    def on_mount(self) -> None:
+        self._show_fields_for(self._settings.transport)
+        self.query_one("#connect", Button).focus()
+
+    def _show_fields_for(self, transport: str) -> None:
+        """Show only the pair the chosen transport actually uses."""
+        unix = transport == "unix"
+        for widget_id in ("#socket-label", "#socket"):
+            self.query_one(widget_id).display = unix
+        for widget_id in ("#host-label", "#host", "#port-label", "#port"):
+            self.query_one(widget_id).display = not unix
+
+    @on(Select.Changed, "#transport")
+    def _transport_changed(self, event: Select.Changed) -> None:
+        self._show_fields_for(str(event.value))
+
+    @on(Input.Submitted)
+    def _submit_on_enter(self) -> None:
+        self._connect()
+
+    @on(Button.Pressed, "#connect")
+    def _connect_pressed(self) -> None:
+        self._connect()
+
+    @on(Button.Pressed, "#cancel")
+    def _cancel_pressed(self) -> None:
+        self.action_cancel()
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+    def _connect(self) -> None:
+        transport = str(self.query_one("#transport", Select).value)
+        port_text = self.query_one("#port", Input).value.strip()
+        try:
+            port = int(port_text) if port_text else self._settings.port
+        except ValueError:
+            # A typo in the port is worth one sentence, not a dismissed dialog that
+            # silently connects somewhere else.
+            self.query_one("#connect-intro", Static).update(labels.bad_port(port_text))
+            return
+
+        self.dismiss(
+            Address(
+                transport=transport,
+                socket=Path(
+                    self.query_one("#socket", Input).value.strip()
+                    or self._settings.socket
+                ).expanduser(),
+                host=self.query_one("#host", Input).value.strip()
+                or self._settings.host,
+                port=port,
+            )
+        )
+
+
+__all__ = ["ConnectScreen"]

stcode/cli/ui/screens/connect.tcss

@@ -0,0 +1,49 @@
+ConnectScreen {
+    align: center middle;
+}
+
+#connect-dialog {
+    width: 72;
+    max-width: 96%;
+    height: auto;
+    padding: 1 2;
+    border: none;
+    background: $surface;
+}
+
+#connect-title {
+    text-style: bold;
+    color: $accent;
+}
+
+#connect-intro {
+    color: $text-muted;
+    margin-bottom: 1;
+}
+
+#connect-dialog Input, #connect-dialog Select, #connect-dialog SelectCurrent {
+    height: 1;
+    border: none;
+    padding: 0 1;
+    background: $boost;
+    margin-bottom: 1;
+}
+
+#connect-dialog Input:focus, #connect-dialog Select:focus SelectCurrent {
+    background: $primary 30%;
+}
+
+.field-label {
+    text-style: bold;
+    color: $accent;
+}
+
+#connect-buttons {
+    height: auto;
+    margin-top: 1;
+    align-horizontal: right;
+}
+
+#connect-buttons Button {
+    margin-left: 2;
+}

stcode/cli/ui/screens/dialog.tcss

@@ -0,0 +1,40 @@
+TrustScreen, SessionsScreen {
+    align: center middle;
+    background: $background 70%;
+}
+
+#dialog {
+    width: 80;
+    max-width: 92%;
+    height: auto;
+    max-height: 80%;
+    padding: 1 2;
+    border: none;
+    background: $surface;
+}
+
+#dialog-title {
+    text-style: bold;
+    color: $text-primary;
+    margin-bottom: 1;
+}
+
+#dialog-body {
+    height: auto;
+    margin-bottom: 1;
+}
+
+#dialog-buttons {
+    height: auto;
+    align-horizontal: right;
+}
+
+#dialog-buttons Button {
+    margin-left: 2;
+}
+
+#session-tree {
+    height: auto;
+    max-height: 16;
+    margin-bottom: 1;
+}

stcode/cli/ui/screens/sessions.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from typing import Any, ClassVar, Sequence
+
+from rich.text import Text
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, Static, Tree
+from textual.widgets.tree import TreeNode
+
+from stcode.cli import labels
+
+
+class SessionsScreen(ModalScreen[str]):
+    """Pick an earlier session to resume. Returns its id, or "" if nothing was picked.
+
+    A tree, because sub-agent sessions are rows in the same listing: `parent` and
+    `agent_name` are already in every `meta` line, so the shape is a group-by and not
+    an index.
+
+    **Only a parent is selectable.** A sub-agent's session is a transcript to read, not
+    a conversation to continue — there is no user on the other end of it, and it was
+    built to answer exactly one question.
+    """
+
+    CSS_PATH = "dialog.tcss"
+
+    BINDINGS: ClassVar[list[BindingType]] = [Binding("escape", "cancel", "Cancel")]
+
+    def __init__(self, rows: Sequence[dict[str, Any]]) -> None:
+        super().__init__()
+        self._rows = list(rows)
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="dialog"):
+            yield Label(labels.SESSIONS_TITLE, id="dialog-title")
+            if not self._rows:
+                yield Static(labels.SESSIONS_EMPTY, id="dialog-body", markup=False)
+            else:
+                yield Static(
+                    Text(labels.SESSIONS_INTRO, style="dim"),
+                    id="dialog-body",
+                    markup=False,
+                )
+                yield self._tree()
+            with Horizontal(id="dialog-buttons"):
+                yield Button(labels.BUTTON_CANCEL, id="cancel")
+
+    def _tree(self) -> Tree[dict[str, Any]]:
+        tree: Tree[dict[str, Any]] = Tree("sessions", id="session-tree")
+        tree.show_root = False
+        tree.guide_depth = 3
+
+        children: dict[str, list[dict[str, Any]]] = {}
+        for row in self._rows:
+            parent = str(row.get("parent", ""))
+            if parent:
+                children.setdefault(parent, []).append(row)
+
+        known = {str(row.get("id", "")) for row in self._rows}
+        for row in self._rows:
+            parent = str(row.get("parent", ""))
+            # An orphan — its parent has been pruned — is shown at the top level rather
+            # than hidden. A transcript you cannot find is a transcript you have lost.
+            if parent and parent in known:
+                continue
+            node = tree.root.add(self._label(row), data=row, expand=True)
+            for child in children.get(str(row.get("id", "")), []):
+                node.add_leaf(self._child_label(child), data=child)
+        return tree
+
+    def _label(self, row: dict[str, Any]) -> Text:
+        text = Text()
+        text.append(labels.session_line(row), style="bold" if row.get("live") else "")
+        summary = str(row.get("summary", ""))
+        if summary:
+            text.append(f"  {summary}", style="dim")
+        return text
+
+    def _child_label(self, row: dict[str, Any]) -> Text:
+        return Text(labels.subsession_line(row), style="dim")
+
+    def on_mount(self) -> None:
+        if self._rows:
+            self.query_one("#session-tree", Tree).focus()
+        else:
+            self.query_one("#cancel", Button).focus()
+
+    @on(Tree.NodeSelected)
+    def _selected(self, event: Tree.NodeSelected[dict[str, Any]]) -> None:
+        node: TreeNode[dict[str, Any]] = event.node
+        row = node.data or {}
+        if row.get("parent"):
+            return  # A sub-agent's session is readable, not resumable.
+        self.dismiss(str(row.get("id", "")))
+
+    @on(Button.Pressed, "#cancel")
+    def _cancelled(self) -> None:
+        self.action_cancel()
+
+    def action_cancel(self) -> None:
+        self.dismiss("")

stcode/cli/ui/screens/settings.py

@@ -0,0 +1,137 @@
+"""
+Settings screen — the first-run wizard and the `/model` page.
+
+One screen for both, so they cannot drift apart. It shows the daemon's `config` frame
+and dismisses with a `set_config` patch (or `None` if the user backed out); the app
+sends it and the daemon writes its own file. Nothing here touches a disk.
+
+Three fields: provider, key, model. Routing, base URLs and concurrency caps live in the
+daemon's `config.toml`. The key field is disabled when the frame says keys are not
+editable — a daemon reached over TCP accepts none.
+"""
+
+from __future__ import annotations
+
+from typing import Any, ClassVar
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import BindingType
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label, Select, Static
+
+from stcode.cli import labels
+
+
+class SettingsScreen(ModalScreen[dict[str, Any] | None]):
+    """Edit the daemon's default provider, its key, and its model."""
+
+    BINDINGS: ClassVar[list[BindingType]] = [("escape", "cancel", "Cancel")]
+
+    CSS_PATH = "settings.tcss"
+
+    # Textual focuses this once the screen's children exist.
+    AUTO_FOCUS = "#model"
+
+    def __init__(self, config: dict[str, Any], *, first_run: bool = False) -> None:
+        super().__init__()
+        self._config = config
+        self._first_run = first_run
+        self._keys_editable = bool(config.get("keys_editable"))
+
+    def compose(self) -> ComposeResult:
+        provider = str(self._config.get("provider", ""))
+        with Vertical(id="settings-dialog"):
+            yield Static(
+                labels.SETTINGS_TITLE_FIRST_RUN
+                if self._first_run
+                else labels.SETTINGS_TITLE,
+                id="settings-title",
+            )
+            yield Static(
+                labels.SETTINGS_INTRO_FIRST_RUN
+                if self._first_run
+                else labels.SETTINGS_INTRO,
+                id="settings-intro",
+            )
+            with VerticalScroll(id="settings-body"):
+                yield Label(labels.FIELD_PROVIDER, classes="field-label")
+                options = labels.provider_options(self._config)
+                yield Select(
+                    options,
+                    value=provider
+                    if any(value == provider for _, value in options)
+                    else Select.BLANK,
+                    allow_blank=not options,
+                    id="provider",
+                )
+                yield Label(labels.FIELD_API_KEY, classes="field-label")
+                yield Input(
+                    password=True, id="api-key", disabled=not self._keys_editable
+                )
+                yield Static("", id="key-hint", classes="field-hint")
+                yield Label(labels.FIELD_MODEL, classes="field-label")
+                yield Input(id="model")
+            with Horizontal(id="settings-buttons"):
+                yield Button(
+                    labels.BUTTON_SKIP if self._first_run else labels.BUTTON_CANCEL,
+                    id="cancel",
+                )
+                yield Button(labels.BUTTON_SAVE, variant="primary", id="save")
+
+    def on_mount(self) -> None:
+        self._show(str(self._config.get("provider", "")))
+
+    def _entry(self, name: str) -> tuple[dict[str, Any], dict[str, str]]:
+        """The configured entry for `name` (empty when it would be new), and its library."""
+        entry = dict(self._config.get("providers", {}).get(name, {}))
+        library = str(entry.get("provider") or name)
+        return entry, dict(self._config.get("libraries", {}).get(library, {}))
+
+    def _show(self, name: str) -> None:
+        """Fill the key and model fields for one provider entry."""
+        entry, library = self._entry(name)
+        has_key = bool(entry.get("has_key"))
+        key_input = self.query_one("#api-key", Input)
+        key_input.value = ""
+        key_input.placeholder = labels.key_placeholder(has_key)
+        self.query_one("#key-hint", Static).update(
+            labels.key_hint(
+                library.get("key_env", ""),
+                has_key=has_key,
+                editable=self._keys_editable,
+            )
+        )
+        model_input = self.query_one("#model", Input)
+        model_input.value = str(entry.get("model", ""))
+        model_input.placeholder = labels.model_placeholder(
+            library.get("default_model", "")
+        )
+
+    @on(Select.Changed, "#provider")
+    def _provider_changed(self, event: Select.Changed) -> None:
+        if event.value is not Select.BLANK:
+            self._show(str(event.value))
+
+    @on(Input.Submitted)
+    @on(Button.Pressed, "#save")
+    def _save(self) -> None:
+        provider = self.query_one("#provider", Select).value
+        if provider is Select.BLANK:
+            return
+        patch: dict[str, Any] = {
+            "provider": str(provider),
+            "model": self.query_one("#model", Input).value.strip(),
+        }
+        key = self.query_one("#api-key", Input).value.strip()
+        if key:
+            patch["api_key"] = key
+        self.dismiss(patch)
+
+    @on(Button.Pressed, "#cancel")
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
+__all__ = ["SettingsScreen"]

stcode/cli/ui/screens/settings.tcss

@@ -0,0 +1,69 @@
+SettingsScreen {
+    align: center middle;
+}
+
+/* Fixed height with the fields in their own scroller, so the buttons stay on
+   screen on a short terminal instead of sliding below the fold. */
+#settings-dialog {
+    width: 72;
+    max-width: 96%;
+    height: 90%;
+    max-height: 32;
+    padding: 1 2;
+    border: none;
+    background: $surface;
+}
+
+#settings-body {
+    height: 1fr;
+    scrollbar-size-vertical: 1;
+}
+
+#settings-title {
+    text-style: bold;
+    color: $accent;
+}
+
+#settings-intro {
+    color: $text-muted;
+    margin-bottom: 1;
+}
+
+/* Single-row fields: bordered inputs are prettier but cost 3 rows each, which
+   pushes Model and Base URL off a short terminal. Focus reads off the tinted
+   background instead of a border. Select wraps its value in a SelectCurrent that
+   carries its own border, so that has to be flattened too or the field renders
+   as an empty box. */
+#settings-body Input, #settings-body Select, #settings-body SelectCurrent {
+    height: 1;
+    border: none;
+    padding: 0 1;
+    background: $boost;
+}
+
+#settings-body Input:focus, #settings-body Select:focus SelectCurrent {
+    background: $primary 30%;
+}
+
+#settings-body Input, #settings-body Select {
+    margin-bottom: 1;
+}
+
+.field-label {
+    text-style: bold;
+    color: $accent;
+}
+
+.field-hint {
+    color: $text-muted;
+}
+
+#settings-buttons {
+    height: auto;
+    margin-top: 1;
+    align-horizontal: right;
+}
+
+#settings-buttons Button {
+    margin-left: 2;
+}

stcode/cli/ui/screens/trust.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import ClassVar
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, Static
+
+from stcode.cli import labels
+
+
+class TrustScreen(ModalScreen[bool]):
+    """Ask whether the agent may work in this folder. Cancel means leave.
+
+    No third "read-only for a bit" answer: that is `--mode plan` wearing a disguise,
+    and a wall with a side door is a wall people learn to walk around.
+    """
+
+    CSS_PATH = "dialog.tcss"
+
+    BINDINGS: ClassVar[list[BindingType]] = [Binding("escape", "cancel", "Cancel")]
+
+    def __init__(self, path: object) -> None:
+        super().__init__()
+        self._path = str(path)
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="dialog"):
+            yield Label(labels.TRUST_TITLE, id="dialog-title")
+            body = Text()
+            body.append(self._path + "\n\n", style="bold")
+            body.append(labels.TRUST_BODY)
+            yield Static(body, id="dialog-body", markup=False)
+            with Horizontal(id="dialog-buttons"):
+                yield Button(labels.TRUST_NO, id="cancel")
+                yield Button(labels.TRUST_YES, variant="primary", id="trust")
+
+    def on_mount(self) -> None:
+        # Focus lands on Cancel: the reflexive Enter must not be how a folder gets
+        # trusted, for the same reason approval defaults to deny.
+        self.query_one("#cancel", Button).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.dismiss(event.button.id == "trust")
+
+    def action_cancel(self) -> None:
+        self.dismiss(False)