symphony-code 0.0.1__py3-none-any.whl

coding_agent/tui/screens/learning.py

@@ -0,0 +1,113 @@
+"""Learning modal screen."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from rich.console import Group
+from rich.text import Text
+from textual.containers import Container, Horizontal
+from textual.widgets import Static, TabbedContent, TabPane
+
+from coding_agent.addons.learning import LearningStore, Lesson
+from coding_agent.tui.screens.modal import ModalBase, ModalCloseButton, ModalScroll
+from coding_agent.tui.theme import LEARNING_MODAL_CSS
+
+def _human_date(value: str) -> str:
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return value
+    return parsed.strftime("%b %d, %Y")
+
+
+class LearningCard(Container):
+    """A diff-modal-style lesson row with a compact header and body."""
+
+    def __init__(self, lesson: Lesson, index: int) -> None:
+        self.lesson = lesson
+        self.index = index
+        super().__init__(classes="learning-card")
+
+    def compose(self):  # type: ignore[no-untyped-def]
+        lesson = self.lesson
+        confidence_color = "#79a985" if lesson.confidence >= 0.7 else "#d0a85c"
+        meta = Text()
+        meta.append(f"{round(lesson.confidence * 100)}%", style=f"bold {confidence_color}")
+        if lesson.created_at:
+            meta.append(f"  {_human_date(lesson.created_at)}", style="#858d91")
+        if lesson.source_task:
+            meta.append(f"  ·  {lesson.source_task}", style="#858d91")
+        with Horizontal(classes="learning-card-header"):
+            yield Static("◆", classes="learning-marker")
+            yield Static(f"lesson {self.index}", classes="learning-card-title")
+            yield Static(meta, classes="learning-meta")
+        rows: list[object] = []
+        self._append_items(rows, "WHEN TO USE", lesson.applicable_when, "#8eafc2", "›")
+        self._append_items(rows, "WORKED", lesson.worked, "#79a985", "+")
+        self._append_items(rows, "WATCH OUT", lesson.failed, "#c67b82", "−")
+        yield Static(Group(*rows), classes="learning-body-content")
+
+    @staticmethod
+    def _append_items(
+        rows: list[object], label: str, items: list[str], color: str, marker: str
+    ) -> None:
+        if not items:
+            return
+        rows.append(Text(f"\n{label}", style=color))
+        for item in items:
+            line = Text("  ")
+            line.append(f"{marker}  ", style=color)
+            line.append(item, style="#aaaaaa")
+            rows.append(line)
+
+
+# --- learning.py ---
+class LearningModal(ModalBase[None]):
+    """Memory inspector separating current-session provenance from global facts."""
+
+    CSS = LEARNING_MODAL_CSS
+
+    def __init__(
+        self,
+        workspace: Path,
+        *,
+        session_id: str | None = None,
+        store: LearningStore | None = None,
+    ) -> None:
+        super().__init__()
+        self.workspace = workspace
+        self.session_id = session_id
+        self.store = store
+
+    def compose(self):  # type: ignore[no-untyped-def]
+        store = self.store or LearningStore(self.workspace, session_id=self.session_id)
+        session = self.session_id or store.session_id
+        self.store = store
+        with Container(id="learning-pane", classes="modal-pane"):
+            with Horizontal(id="learning-header"):
+                yield Static("learning", id="learning-title")
+                yield Static(
+                    f"session {session[:8]}" if session else "no active session",
+                    id="learning-counter",
+                )
+                yield ModalCloseButton("esc  close", id="modal-close")
+            with TabbedContent(initial="memory-session", id="learning-tabs"):
+                with TabPane("Session", id="memory-session"):
+                    with ModalScroll(id="session-memory-body", classes="modal-body"):
+                        yield Static(
+                            store.scoped_markdown("session", session_id=session),
+                            id="session-memory-content", classes="learning-content", markup=False,
+                        )
+                with TabPane("Global", id="memory-global"):
+                    with ModalScroll(id="global-memory-body", classes="modal-body"):
+                        yield Static(
+                            store.scoped_markdown("global"),
+                            id="global-memory-content", classes="learning-content", markup=False,
+                        )
+            yield Static(
+                "click tabs to switch   ·   ↑↓ scroll   ·   Esc close",
+                id="learning-hint",
+                classes="modal-footer",
+            )

coding_agent/tui/screens/modal.py

@@ -0,0 +1,131 @@
+"""Thin modal host widgets shared by TUI screens."""
+
+from __future__ import annotations
+
+from typing import Generic, TypeVar
+
+from rich.console import Group
+from rich.text import Text
+from textual import events
+from textual.binding import Binding
+from textual.app import ScreenStackError
+from textual.containers import Container, VerticalScroll
+from textual.screen import ModalScreen
+from textual.widgets import Static
+
+from coding_agent.tui.theme import CONTENT_MODAL_CSS
+
+ResultT = TypeVar("ResultT")
+
+
+class ModalCloseButton(Static, can_focus=True):
+    """Small top-right close control shared by all modal screens."""
+
+    def on_click(self, event: events.Click) -> None:
+        event.stop()
+        dismiss_overlay(self.screen)
+
+    def on_key(self, event: events.Key) -> None:
+        if event.key in {"enter", "space"}:
+            event.stop()
+            dismiss_overlay(self.screen)
+
+
+class ModalScroll(VerticalScroll):
+    """Scrollable modal body that always reserves Escape for closing."""
+
+    BINDINGS = [
+        Binding("escape", "close_modal", "Close", show=False, priority=True),
+    ]
+
+    def action_close_modal(self) -> None:
+        dismiss_overlay(self.screen)
+
+    async def _on_key(self, event: events.Key) -> None:
+        if event.key == "escape":
+            event.stop()
+            dismiss_overlay(self.screen)
+            return
+        await super()._on_key(event)
+
+
+class ModalBase(ModalScreen[ResultT], Generic[ResultT]):
+    """Base modal with a consistent close button and Escape behavior."""
+
+    BINDINGS = [
+        Binding("escape", "close_modal", "Close", show=False, priority=True),
+    ]
+
+    def action_close_modal(self) -> None:
+        dismiss_overlay(self)
+
+
+def dismiss_overlay(screen: ModalScreen[object], result: object = None) -> bool:
+    """Dismiss an overlay only while it is still the active extra screen."""
+    app = screen.app
+    if not screen.is_current or len(app.screen_stack) <= 1:
+        return False
+    try:
+        screen.dismiss(result)
+    except ScreenStackError:
+        return False
+    return True
+
+
+def _numbered_text(content: str) -> Text:
+    """Render plain text with a stable, compact line-number gutter.
+
+    This deliberately uses only Rich/Textual primitives; a full diff library is
+    unnecessary for displaying an existing document. ``difflib`` remains the
+    right stdlib tool for comparing two versions, as used by the diff tool.
+    """
+    # ``splitlines`` handles LF, CRLF, and lone CR without leaving carriage
+    # returns in the rendered source. It also preserves intentional blank lines
+    # between lines; a completely empty document still has one visible row.
+    lines = content.splitlines()
+    if not lines:
+        lines = [""]
+    width = max(2, len(str(len(lines))))
+    rendered = Text(no_wrap=True, overflow="crop")
+    for number, line in enumerate(lines, start=1):
+        rendered.append(f"{number:>{width}} │ ", style="#687e8b")
+        rendered.append(line, style="#d0d0d0")
+        if number != len(lines):
+            rendered.append("\n")
+    return rendered
+
+
+class ContentModal(ModalBase[None]):
+    """Modal used to inspect transcript content with a code-style gutter."""
+
+    CSS = CONTENT_MODAL_CSS
+
+    def __init__(self, content: str) -> None:
+        super().__init__()
+        self.content = content
+
+    def compose(self):  # type: ignore[no-untyped-def]
+        with Container(id="content-pane", classes="modal-pane"):
+            yield ModalCloseButton("Esc", id="modal-close")
+            yield Static("Text preview", id="content-title")
+            with ModalScroll(id="content-body", classes="modal-body"):
+                # Keep the raw node for integrations that inspect modal content;
+                # the numbered node is the visible review surface.
+                yield Static(self.content, id="content-text", markup=False)
+                yield Static(_numbered_text(self.content), id="content-numbered", markup=False)
+            yield Static("↑↓ scroll   ·   Esc close", classes="modal-footer")
+
+# --- components.py ---
+class EmptyState(Static):
+    """Friendly empty state shared by data-backed modal screens."""
+
+    def __init__(self, title: str, detail: str, **kwargs: object) -> None:
+        super().__init__(
+            Group(
+                Text("◇", style="bold #738794"),
+                Text(title, style="bold #c8c8c8"),
+                Text(detail, style="#6f6f6f"),
+            ),
+            classes="empty-state",
+            **kwargs,
+        )

coding_agent/tui/screens/onboard.py

@@ -0,0 +1,455 @@
+"""First-run and in-session wizard for adding model provider credentials."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Literal
+
+from rich.text import Text
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Vertical
+from textual.message import Message
+from textual.widgets import Input, OptionList, Static
+from textual.widgets.option_list import Option
+
+from coding_agent.config.credentials import save_provider_auth, save_provider_settings
+from coding_agent.tui.screens.modal import ModalBase, ModalCloseButton, dismiss_overlay
+from coding_agent.tui.theme import ONBOARD_CSS, PROVIDER_MODAL_CSS, SYMPHONY_RICH_THEME
+from core_ai.oauth import LoginCancelled, LoginFlow, save_token, start_login
+from core_ai.providers.catalog import (
+    PROVIDERS,
+    ProviderSpec,
+    configured_provider_ids,
+    get_provider,
+    provider_api_key,
+)
+
+
+def _provider_row(spec: ProviderSpec, configured: bool) -> Option:
+    content = Text("› ")
+    content.append(spec.label)
+    content.append("\n  ")
+    if configured:
+        content.append("ready", style="#799e7c")
+        badge = spec.base_url_env if not spec.requires_key and spec.base_url_env else spec.env_key
+        if spec.supports_oauth:
+            badge = f"{badge} or subscription"
+        content.append(f"   {badge}", style="#555555")
+    else:
+        content.append(spec.description, style="#737373")
+    return Option(content, id=f"provider:{spec.id}")
+
+
+def _continue_row(configured: tuple[str, ...]) -> Option:
+    labels = ", ".join(get_provider(provider_id).label for provider_id in configured)
+    content = Text("Continue")
+    content.append("\n  ")
+    content.append(f"Use {labels}", style="#737373")
+    return Option(content, id="continue")
+
+
+def _method_row(method_id: str, title: str, detail: str) -> Option:
+    content = Text("› ")
+    content.append(title)
+    content.append("\n  ")
+    content.append(detail, style="#737373")
+    return Option(content, id=f"method:{method_id}")
+
+
+def _oauth_methods(spec: ProviderSpec) -> list[Option]:
+    if spec.id == "openai":
+        oauth = _method_row("oauth", "Sign in with ChatGPT", "Use a ChatGPT Plus / Pro / Codex subscription")
+    elif spec.id == "anthropic":
+        oauth = _method_row("oauth", "Sign in with Claude", "Paste a setup-token or browser code")
+    else:
+        oauth = _method_row("oauth", "Sign in with xAI", "Device login for SuperGrok / Premium+")
+    if not spec.requires_key:
+        key_label = "Paste endpoint"
+    elif provider_api_key(spec):
+        key_label = "Use existing API key"
+    else:
+        key_label = "Paste API key"
+    return [oauth, _method_row("key", key_label, spec.env_key if spec.requires_key else spec.description)]
+
+
+class ProviderWizard(Vertical):
+    """Pick a provider, choose sign-in vs key, then continue."""
+
+    class Completed(Message):
+        def __init__(self, providers: tuple[str, ...]) -> None:
+            super().__init__()
+            self.providers = providers
+
+    def __init__(
+        self,
+        workspace: str | Path,
+        *,
+        initial_provider: str | None = None,
+        first_run: bool = False,
+        **kwargs: object,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.workspace = Path(workspace)
+        self.initial_provider = initial_provider
+        self.first_run = first_run
+        self.step: Literal["pick", "method", "key", "oauth"] = "pick"
+        self._pending: str | None = None
+        self._highlight_continue = False
+        self._flow: LoginFlow | None = None
+        self._oauth_done = False
+
+    def compose(self) -> ComposeResult:
+        yield Static("Add a provider", id="onboard-title")
+        yield Static(
+            "Choose where Symphony should send model calls. You can add more than one.",
+            id="onboard-subtitle",
+        )
+        yield Static("", id="onboard-detail")
+        yield OptionList(id="provider-list")
+        yield Input(password=True, id="provider-key")
+        yield Static("", id="onboard-error")
+        yield Static(self._hint_text(), id="onboard-hint")
+
+    def on_mount(self) -> None:
+        self.query_one("#provider-key", Input).display = False
+        self.query_one("#onboard-detail", Static).display = False
+        if self.initial_provider:
+            spec = get_provider(self.initial_provider)
+            if spec.supports_oauth:
+                self.show_method(self.initial_provider)
+            else:
+                self.show_key(self.initial_provider)
+        else:
+            self.show_pick()
+
+    def show_pick(self) -> None:
+        self._close_flow()
+        self.step = "pick"
+        self._pending = None
+        self.query_one("#onboard-title", Static).update("Add a provider")
+        self.query_one("#onboard-subtitle", Static).update(
+            "Choose where Symphony should send model calls. You can add more than one."
+        )
+        self.query_one("#onboard-error", Static).update("")
+        self.query_one("#onboard-detail", Static).update("")
+        self.query_one("#onboard-detail", Static).display = False
+        self.query_one("#provider-key", Input).display = False
+        listing = self.query_one("#provider-list", OptionList)
+        listing.display = True
+        self._refresh_list()
+        listing.focus()
+        self._set_hint()
+
+    def show_method(self, provider_id: str) -> None:
+        spec = get_provider(provider_id)
+        if not spec.supports_oauth:
+            self.show_key(provider_id)
+            return
+        self._close_flow()
+        self.step = "method"
+        self._pending = provider_id
+        self.query_one("#onboard-title", Static).update(spec.label)
+        self.query_one("#onboard-subtitle", Static).update(
+            "Sign in with a subscription, or use an API key."
+        )
+        self.query_one("#onboard-error", Static).update("")
+        self.query_one("#onboard-detail", Static).display = False
+        self.query_one("#provider-key", Input).display = False
+        listing = self.query_one("#provider-list", OptionList)
+        listing.display = True
+        listing.set_options(_oauth_methods(spec))
+        listing.highlighted = 0
+        listing.focus()
+        self._set_hint()
+
+    def show_key(self, provider_id: str) -> None:
+        spec = get_provider(provider_id)
+        self._close_flow()
+        self.step = "key"
+        self._pending = provider_id
+        key_input = self.query_one("#provider-key", Input)
+        if spec.requires_key:
+            self.query_one("#onboard-title", Static).update(f"{spec.label} API key")
+            self.query_one("#onboard-subtitle", Static).update(
+                f"Paste a key from {spec.docs_url}"
+            )
+            key_input.password = True
+            key_input.placeholder = spec.key_placeholder
+        else:
+            self.query_one("#onboard-title", Static).update(f"{spec.label} endpoint")
+            self.query_one("#onboard-subtitle", Static).update(spec.description)
+            key_input.password = False
+            key_input.placeholder = spec.default_base_url or spec.key_placeholder
+        self.query_one("#onboard-error", Static).update("")
+        self.query_one("#onboard-detail", Static).display = False
+        self.query_one("#provider-list", OptionList).display = False
+        key_input.value = ""
+        key_input.display = True
+        key_input.focus()
+        self._set_hint()
+
+    def show_oauth(self, provider_id: str) -> None:
+        self._close_flow()
+        self.step = "oauth"
+        self._pending = provider_id
+        self._oauth_done = False
+        try:
+            flow = start_login(provider_id)
+        except Exception as exc:
+            # Do not leave a preference behind when login could not start.
+            self.show_method(provider_id)
+            self.query_one("#onboard-error", Static).update(str(exc))
+            return
+        self._flow = flow
+        prompt = flow.prompt
+        self.query_one("#onboard-title", Static).update(prompt.title)
+        if prompt.user_code:
+            self.query_one("#onboard-subtitle", Static).update(f"Code: {prompt.user_code}")
+        else:
+            self.query_one("#onboard-subtitle", Static).update("Finish in the browser, or paste below.")
+        detail_parts = [prompt.instructions]
+        if prompt.url:
+            detail_parts.append(prompt.url)
+        detail_widget = self.query_one("#onboard-detail", Static)
+        detail_widget.update("\n".join(detail_parts))
+        detail_widget.display = True
+        self.query_one("#onboard-error", Static).update("")
+        self.query_one("#provider-list", OptionList).display = False
+        key_input = self.query_one("#provider-key", Input)
+        if prompt.kind == "device":
+            key_input.display = False
+        else:
+            key_input.password = False
+            key_input.placeholder = prompt.paste_hint
+            key_input.value = ""
+            key_input.display = True
+            key_input.focus()
+        self._set_hint()
+        self.app.run_worker(self._wait_oauth(), exclusive=True)
+
+    def finish(self) -> None:
+        self._close_flow()
+        self.post_message(self.Completed(configured_provider_ids()))
+
+    def cancel(self) -> bool:
+        """Handle Escape. Returns True when the host should close."""
+        if self.step == "oauth":
+            pending = self._pending
+            self._close_flow()
+            if pending:
+                self.show_method(pending)
+            else:
+                self.show_pick()
+            return False
+        if self.step == "key":
+            pending = self._pending
+            if pending and get_provider(pending).supports_oauth:
+                self.show_method(pending)
+            else:
+                self.show_pick()
+            return False
+        if self.step == "method":
+            self.show_pick()
+            return False
+        self.finish()
+        return True
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        event.stop()
+        option_id = event.option_id or ""
+        if option_id == "continue":
+            self.finish()
+            return
+        if option_id.startswith("provider:"):
+            provider_id = option_id.split(":", 1)[1]
+            spec = get_provider(provider_id)
+            if spec.supports_oauth:
+                self.show_method(provider_id)
+            else:
+                self.show_key(provider_id)
+            return
+        if option_id == "method:oauth" and self._pending:
+            self.show_oauth(self._pending)
+            return
+        if option_id == "method:key" and self._pending:
+            spec = get_provider(self._pending)
+            if spec.requires_key and provider_api_key(spec):
+                save_provider_auth(self._pending, "key")
+                self._highlight_continue = True
+                self.show_pick()
+                return
+            self.show_key(self._pending)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        event.stop()
+        if self.step == "oauth":
+            self._submit_oauth_paste(event.value)
+            return
+        if self._pending is None or self.step != "key":
+            return
+        spec = get_provider(self._pending)
+        try:
+            if spec.requires_key:
+                save_provider_settings(self._pending, api_key=event.value)
+                save_provider_auth(self._pending, "key")
+            else:
+                save_provider_settings(self._pending, base_url=event.value)
+        except ValueError as exc:
+            self.query_one("#onboard-error", Static).update(str(exc))
+            return
+        self._highlight_continue = True
+        self.show_pick()
+
+    def _submit_oauth_paste(self, pasted: str) -> None:
+        if self._flow is None:
+            return
+        try:
+            token = self._flow.complete_from_paste(pasted)
+        except ValueError as exc:
+            self.query_one("#onboard-error", Static).update(str(exc))
+            return
+        except Exception as exc:
+            self.query_one("#onboard-error", Static).update(str(exc))
+            return
+        self._finish_oauth(token)
+
+    async def _wait_oauth(self) -> None:
+        flow = self._flow
+        if flow is None:
+            return
+        try:
+            token = await asyncio.to_thread(flow.wait)
+        except LoginCancelled:
+            return
+        except Exception as exc:
+            self._oauth_failed(str(exc))
+            return
+        self._finish_oauth(token)
+
+    def _oauth_failed(self, message: str) -> None:
+        if self.step != "oauth":
+            return
+        self.query_one("#onboard-error", Static).update(message)
+
+    def _finish_oauth(self, token: object) -> None:
+        if self._oauth_done or self.step != "oauth" or self._pending is None:
+            return
+        from core_ai.oauth.types import OAuthToken
+
+        if not isinstance(token, OAuthToken):
+            return
+        self._oauth_done = True
+        save_token(self._pending, token)
+        save_provider_auth(self._pending, "oauth")
+        self._close_flow()
+        self._highlight_continue = True
+        self.show_pick()
+
+    def _close_flow(self) -> None:
+        flow = self._flow
+        self._flow = None
+        if flow is not None:
+            flow.close()
+
+    def _refresh_list(self) -> None:
+        configured = configured_provider_ids()
+        options = [_provider_row(spec, spec.id in configured) for spec in PROVIDERS]
+        if configured:
+            options.append(_continue_row(configured))
+        listing = self.query_one("#provider-list", OptionList)
+        listing.set_options(options)
+        if configured and self._highlight_continue:
+            listing.highlighted = listing.option_count - 1
+            self._highlight_continue = False
+        elif listing.option_count:
+            listing.highlighted = 0
+
+    def _hint_text(self) -> str:
+        if self.step == "oauth":
+            if self._flow is not None and self._flow.prompt.kind == "device":
+                return "Approve in the browser   Esc back"
+            return "Enter paste code   Esc back"
+        if self.step == "method":
+            return "↑↓ select   Enter continue   Esc back"
+        if self.step == "key":
+            if self._pending and not get_provider(self._pending).requires_key:
+                spec = get_provider(self._pending)
+                if spec.default_base_url:
+                    return "Enter save (blank uses default)   Esc back"
+                return "Enter save   Esc back"
+            return "Enter save   Esc back"
+        close = "skip" if self.first_run else "close"
+        if configured_provider_ids():
+            return f"↑↓ select   Enter add   Continue starts   Esc {close}"
+        return f"↑↓ select   Enter add   Esc {close}"
+
+    def _set_hint(self) -> None:
+        self.query_one("#onboard-hint", Static).update(self._hint_text())
+
+
+class OnboardApp(App[tuple[str, ...]]):
+    """Full-screen first-run provider setup, matching the resume selector."""
+
+    CSS = ONBOARD_CSS
+    BINDINGS = [
+        Binding("escape", "cancel", "skip"),
+        Binding("ctrl+c", "cancel", "quit", show=False),
+    ]
+
+    def __init__(self, workspace: str | Path) -> None:
+        super().__init__()
+        self.workspace = Path(workspace)
+
+    def compose(self) -> ComposeResult:
+        with Container(id="onboard-page"):
+            yield ProviderWizard(self.workspace, first_run=True)
+
+    def on_mount(self) -> None:
+        self.console.push_theme(SYMPHONY_RICH_THEME, inherit=True)
+        wizard = self.query_one(ProviderWizard)
+        if wizard.step == "pick":
+            self.query_one("#provider-list", OptionList).focus()
+
+    def on_provider_wizard_completed(self, event: ProviderWizard.Completed) -> None:
+        event.stop()
+        self.exit(event.providers)
+
+    def action_cancel(self) -> None:
+        wizard = self.query_one(ProviderWizard)
+        if not wizard.cancel():
+            return
+        self.exit(configured_provider_ids())
+
+
+class ProviderOnboardScreen(ModalBase[tuple[str, ...] | None]):
+    """In-session overlay for `/provider`."""
+
+    CSS = PROVIDER_MODAL_CSS
+
+    def __init__(
+        self,
+        workspace: str | Path,
+        *,
+        initial_provider: str | None = None,
+    ) -> None:
+        super().__init__()
+        self.workspace = Path(workspace)
+        self.initial_provider = initial_provider
+
+    def compose(self) -> ComposeResult:
+        with Container(id="provider-pane", classes="modal-pane"):
+            yield ModalCloseButton("Esc", id="modal-close")
+            yield ProviderWizard(
+                self.workspace,
+                initial_provider=self.initial_provider,
+            )
+
+    def on_provider_wizard_completed(self, event: ProviderWizard.Completed) -> None:
+        event.stop()
+        dismiss_overlay(self, event.providers)
+
+    def action_close_modal(self) -> None:
+        wizard = self.query_one(ProviderWizard)
+        wizard.cancel()