@scemoon/cdh 1.0.0

package/tui/screens/sessions.py

@@ -0,0 +1,166 @@
+import json
+from time import monotonic
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.events import ScreenResume
+from textual.screen import ModalScreen
+from textual import getters
+from textual.widget import Widget
+from textual import widgets
+from textual import containers
+from textual import on
+
+
+from onecode.config import CLOUD_DEV_HARNESS_DIR
+
+from tui.app import A2TUIApp
+from tui.db import DB
+from tui.widgets.grid_select import GridSelect
+from tui.widgets.session_grid_select import (
+    SessionGridSelect,
+    PAGE_INDICATOR_ID,
+)
+from tui.widgets.session_summary import SessionSummary
+from tui.session_tracker import SessionDetails
+
+
+CONFIRM_TIMEOUT = 5.0
+INSTRUCTIONS_NO_SESSIONS = "Your sessions will be shown here."
+
+
+class SessionsScreen(ModalScreen[str]):
+    CSS_PATH = "sessions.tcss"
+    BINDINGS = [
+        Binding("escape", "dismiss", "Dismiss"),
+        Binding("d", "delete_session", "Delete"),
+    ]
+
+    app: getters.app[A2TUIApp] = getters.app(A2TUIApp)
+    session_grid_select = getters.query_one(SessionGridSelect)
+    _delete_confirm_time: float = 0.0
+
+    def compose(self) -> ComposeResult:
+        with containers.Center(id="title-container"):
+            yield widgets.Label("Sessions")
+        yield widgets.Static(INSTRUCTIONS_NO_SESSIONS, classes="instructions")
+        yield widgets.Static("", id=PAGE_INDICATOR_ID)
+        yield SessionGridSelect(self.app.session_tracker, id="session-grid")
+        yield widgets.Footer()
+
+    @property
+    def focus_chain(self) -> list[Widget]:
+        return [self.session_grid_select]
+
+    async def action_delete_session(self) -> None:
+        now = monotonic()
+        if now - self._delete_confirm_time > CONFIRM_TIMEOUT:
+            self._delete_confirm_time = now
+            self.notify(
+                "Press [b]d[/b] again to confirm deletion",
+                title="Delete session",
+                timeout=CONFIRM_TIMEOUT,
+            )
+            return
+
+        self._delete_confirm_time = 0.0
+        highlighted = self.session_grid_select.highlighted
+        if highlighted is None:
+            return
+        try:
+            widget = self.session_grid_select.children[highlighted]
+        except IndexError:
+            return
+        if not isinstance(widget, SessionSummary):
+            return
+        session_details = widget.session_details
+        if session_details is None:
+            return
+        session_pk = session_details.session_pk
+        if session_pk is None:
+            self.notify("Cannot delete unsaved session", severity="error")
+            return
+
+        db = DB()
+        session = await db.session_get(session_pk)
+        if session is None:
+            return
+
+        agent_session_id = session.get("agent_session_id", "")
+        title = session.get("title", "Untitled") or "Untitled"
+
+        await db.session_delete(session_pk)
+
+        if agent_session_id:
+            session_file = CLOUD_DEV_HARNESS_DIR / "sessions" / f"{agent_session_id}.json"
+            if session_file.exists():
+                session_file.unlink()
+
+        mode_name = session_details.mode_name
+        if self.app.session_tracker.get_session(mode_name):
+            self.app.session_tracker.close_session(mode_name)
+
+        await widget.remove()
+        self.notify(f"Deleted session: {title}")
+
+    async def _load_historical_sessions(self) -> None:
+        seen_pks: set[int] = set()
+        merged: list[SessionDetails] = []
+
+        for session in self.app.session_tracker.ordered_sessions:
+            if session.session_pk is not None and session.session_pk in seen_pks:
+                continue
+            if session.session_pk is not None:
+                seen_pks.add(session.session_pk)
+            merged.append(session)
+
+        db = DB()
+        sessions = await db.session_get_recent(max_results=20)
+        for session in sessions or []:
+            session_id = session["id"]
+            if session_id in seen_pks:
+                continue
+            seen_pks.add(session_id)
+            cwd = ""
+            if meta_json := session.get("meta_json"):
+                try:
+                    cwd = json.loads(meta_json).get("cwd", "")
+                except Exception:
+                    pass
+            merged.append(
+                SessionDetails(
+                    index=session_id,
+                    mode_name=f"session-{session_id}",
+                    session_pk=session_id,
+                    title=session.get("title", "Untitled") or "Untitled",
+                    subtitle=session.get("agent", ""),
+                    path=cwd,
+                    state="idle",
+                )
+            )
+
+        self.session_grid_select.set_sessions(merged)
+
+    def on_mount(self) -> None:
+        self.run_worker(self._load_historical_sessions())
+
+    async def _on_screen_resume(self, event: ScreenResume) -> None:
+        current_mode = self.app.screen_stack[0].id
+        for instructions in self.query(".instructions"):
+            instructions.display = not self.session_grid_select.children
+        if current_mode is not None:
+            self.session_grid_select.update_current(current_mode)
+
+    def _on_screen_suspend(self) -> None:
+        current_mode = self.app.screen_stack[0].id
+        if current_mode is not None:
+            self.session_grid_select.update_current(current_mode)
+
+    @on(GridSelect.Selected)
+    def on_selected(self, event: GridSelect.Selected) -> None:
+        if (
+            isinstance(event.widget, SessionSummary)
+            and event.widget.session_details is not None
+        ):
+            mode_name = event.widget.session_details.mode_name
+            self.dismiss(mode_name)

package/tui/screens/sessions.tcss

@@ -0,0 +1,119 @@
+SessionsScreen {
+    
+    # background: transparent;
+    # background: $background 40%;
+    background: $background;
+
+
+    #title-container {
+        padding: 1 1 0 1;              
+        color: $text-success;
+        visibility: hidden;
+        & > * {
+            visibility: visible;
+        }
+    }
+
+    .instructions {
+        width: auto;
+        margin: 1 1;
+        color: $text-muted;
+        text-style: italic;
+    }
+
+
+    SessionGridSelect {
+        width: 1fr;
+        margin: 0 1 1 1;
+        padding: 1 0 !important;
+    }
+
+    SessionSummary {       
+        border: blank transparent;
+        background: black 10%;
+        width: auto;
+            
+        margin: 0;
+        pointer: pointer;
+        height: auto;
+        padding: 1 0 1 0;
+
+        Rule {
+            margin: 0;
+        }
+        
+        &.-highlight {                           
+            border: round $primary;            
+        }
+    
+        CondensedPath {
+            color: $text-warning;
+            width: 1fr;
+        }
+        
+        BusyIndicator {
+            display: None;   
+            text-opacity: 0.85;     
+        }
+
+        &.-state-busy {
+            padding: 0 0 1 0;
+            Rule {
+                display: none;
+            }
+            BusyIndicator {
+                display: block;
+            }
+        }
+        &.-state-idle {
+            .icon {
+                color: $text-secondary;
+            }
+            Rule {
+                display: block;
+                color: $text-secondary;
+            }
+            BusyIndicator {
+                display: none;
+            }
+        }
+        &.-state-asking {
+            .icon {
+                color: $text-accent;
+            }
+            Rule {
+                color: $text-accent;
+            }
+            &.-blink {
+                .icon {
+                    opacity: 0.2;
+                }
+                Rule {
+                    opacity: 0.2;
+                }
+            }
+        }
+        
+
+        .icon {            
+            width: 3;
+            text-align: center;
+            color: $text-secondary;
+        }
+
+        .title {
+            width: 1fr;
+        }
+        .subtitle {
+            color: $text-secondary;
+            text-style: italic; 
+        }
+        BusyIndicator {
+            opacity: 1;
+        }
+        &.-state-busy BusyIndicator {
+            opacity: 1;
+        }
+    }
+
+}

package/tui/screens/settings.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+from textual import on
+from textual.app import ComposeResult
+from textual import lazy
+from textual import containers
+from textual.content import Content
+from textual.screen import ModalScreen, ScreenResultType
+from textual.widgets import Input, Select, Checkbox, Footer, Static, TextArea
+from textual.compose import compose
+from textual.validation import Validator, Number
+from textual import getters
+
+
+from tui.settings import Setting
+from tui.app import A2TUIApp
+
+
+class SettingsInput(Input):
+    pass
+
+
+class SettingsScreen(ModalScreen):
+    BINDINGS = [
+        ("escape", "dismiss", "Dismiss settings"),
+        ("ctrl+s", "screen.focus('#search')", "Focus search"),
+    ]
+    CSS_PATH = "settings.tcss"
+
+    app = getters.app(A2TUIApp)
+
+    search_input = getters.query_one("Input#search", Input)
+
+    AUTO_FOCUS = "Input#search"
+
+    def compose(self) -> ComposeResult:
+        settings = self.app.settings
+        schema = self.app.settings_schema
+
+        def schema_to_widget(
+            group_title: str, settings_map: dict[str, Setting]
+        ) -> ComposeResult:
+            for _key, setting in settings_map.items():
+                if not setting.editable:
+                    continue
+                if setting.type == "object":
+                    if setting.children is not None:
+                        with containers.VerticalGroup(classes="setting-object"):
+                            with containers.VerticalGroup(classes="heading"):
+                                yield Static(setting.title, classes="title")
+                                yield Static(setting.help, classes="help")
+                            with containers.VerticalGroup(
+                                id="setting-group", classes="setting-group"
+                            ):
+                                yield from compose(
+                                    self,
+                                    schema_to_widget(setting.title, setting.children),
+                                )
+
+                else:
+                    with containers.VerticalGroup(
+                        classes="setting",
+                        name=f"{group_title.lower()} {setting.title.lower()}",
+                    ):
+                        value = settings.get(setting.key, object, expand=False)
+                        default = settings.schema.get_default(setting.key)
+
+                        if setting.type == "text" or default is None:
+                            help = Content.from_markup(setting.help)
+                        else:
+                            if setting.type == "choices":
+                                # For choices we need to translate the default to its associated label
+                                choices = setting.choices or []
+                                for choice in choices:
+                                    if isinstance(choice, tuple):
+                                        title, choice_value = choice
+                                    else:
+                                        title = choice_value = choice
+                                    if default == choice_value:
+                                        default = title
+                                else:
+                                    help = Content()
+
+                            if setting.help:
+                                help = Content.assemble(
+                                    Content.from_markup(setting.help),
+                                    (f"\ndefault: {default!r}", "$text-secondary"),
+                                )
+                            else:
+                                help = Content.styled(
+                                    f"default: {default!r}", "$text-secondary"
+                                )
+
+                        yield Static(setting.title, classes="title")
+                        if help:
+                            yield Static(help, classes="help")
+                        if setting.type == "string":
+                            with self.prevent(Input.Changed):
+                                yield Input(
+                                    str(value), classes="input", name=setting.key
+                                )
+                        if setting.type == "text":
+                            # with self.prevent(TextArea.Changed):
+                            yield TextArea(
+                                str(value), classes="input", name=setting.key
+                            )
+                        elif setting.type == "boolean":
+                            with self.prevent(Checkbox.Changed):
+                                yield Checkbox(
+                                    value=bool(value),
+                                    classes="input",
+                                    name=setting.key,
+                                )
+                        elif setting.type == "integer":
+                            try:
+                                integer_value = int(value)
+                            except (ValueError, TypeError):
+                                integer_value = setting.default
+                            setting_validate = setting.validate or []
+                            validators: list[Validator] = []
+                            for validate in setting_validate:
+                                validate_type = validate["type"]
+                                if validate_type == "minimum":
+                                    validators.append(Number(minimum=validate["value"]))
+                                elif validate_type == "maximum":
+                                    validators.append(Number(maximum=validate["value"]))
+                            with self.prevent(Input.Changed):
+                                yield Input(
+                                    str(integer_value),
+                                    type="integer",
+                                    classes="input",
+                                    name=setting.key,
+                                    validators=validators,
+                                )
+                        elif setting.type == "number":
+                            try:
+                                integer_value = float(value)
+                            except (ValueError, TypeError):
+                                integer_value = setting.default
+                            setting_validate = setting.validate or []
+                            validators: list[Validator] = []
+                            for validate in setting_validate:
+                                validate_type = validate["type"]
+                                if validate_type == "minimum":
+                                    validators.append(Number(minimum=validate["value"]))
+                                elif validate_type == "maximum":
+                                    validators.append(Number(maximum=validate["value"]))
+                            with self.prevent(Input.Changed):
+                                yield Input(
+                                    str(integer_value),
+                                    type="number",
+                                    classes="input",
+                                    name=setting.key,
+                                    validators=validators,
+                                )
+                        elif setting.type == "choices":
+                            select_value = str(value)
+                            choices = setting.choices or []
+                            with self.prevent(Select.Changed):
+                                select_choices = [
+                                    (
+                                        choice
+                                        if isinstance(choice, tuple)
+                                        else (choice, choice)
+                                    )
+                                    for choice in choices
+                                ]
+                                choices_set = {choice[1] for choice in select_choices}
+                                yield Select(
+                                    select_choices,
+                                    value=(
+                                        select_value
+                                        if select_value in choices_set
+                                        else setting.default
+                                    ),
+                                    classes="input",
+                                    name=setting.key,
+                                    allow_blank=setting.default is None,
+                                )
+
+        with containers.Vertical(id="contents"):
+            with containers.VerticalGroup(classes="search-container"):
+                yield Input(id="search", placeholder="Search settings")
+            with lazy.Reveal(
+                containers.VerticalScroll(can_focus=False, id="settings-container")
+            ):
+                yield from compose(self, schema_to_widget("", schema.settings_map))
+
+        yield Footer()
+
+    @on(Input.Blurred, "Input")
+    @on(Input.Submitted, "Input")
+    def on_input_blurred(self, event: Input.Blurred) -> None:
+        if event.validation_result and not event.validation_result.is_valid:
+            self.notify(
+                event.validation_result.failures[0].description or "error",
+                title=event.input.name or "",
+                severity="error",
+            )
+            event.input.value = str(
+                self.app.settings.get(event.input.name or "", expand=False)
+            )
+            return
+        if event.input.name is not None:
+            if event.input.type == "integer":
+                self.app.settings.set(event.input.name, int(event.value or "0"))
+            elif event.input.type == "number":
+                self.app.settings.set(event.input.name, float(event.value or "0"))
+            else:
+                self.app.settings.set(event.input.name, event.value)
+
+    @on(TextArea.Changed)
+    def on_text_area_changed(self, event: TextArea.Changed) -> None:
+        if event.text_area.name is not None:
+            self.app.settings.set(event.text_area.name, event.text_area.text)
+
+    @on(Checkbox.Changed)
+    def on_checkbox_changed(self, event: Checkbox.Changed) -> None:
+        if event.checkbox.name is not None:
+            self.app.settings.set(event.checkbox.name, event.checkbox.value)
+
+    @on(Select.Changed)
+    def on_select_changed(self, event: Select.Changed) -> None:
+        if event.select.name is not None:
+            self.app.settings.set(event.select.name, event.select.value)
+
+    def filter_settings(self, search_term: str) -> None:
+        if search_term:
+            search_term = search_term.lower()
+            for setting in self.query(".setting"):
+                if setting.name:
+                    setting.display = search_term in setting.name
+            for container in reversed(self.query(".setting-object")):
+                container.display = not container.get_child_by_id(
+                    "setting-group"
+                ).is_empty
+        else:
+            self.query(".setting").set(display=True)
+            self.query(".setting-object").set(display=True)
+
+    @on(Input.Changed, "#search")
+    def on_search_input(self, event: Input.Changed) -> None:
+        self.filter_settings(event.value)
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        if action == "focus":
+            if not self.is_mounted:
+                return None
+            return None if self.search_input.has_focus else True
+        return True
+
+    async def action_dismiss(self, result: ScreenResultType | None = None) -> None:
+        self.query("#search").focus()
+        self.call_after_refresh(self.dismiss, result)

package/tui/screens/settings.tcss

@@ -0,0 +1,101 @@
+
+SettingsScreen {    
+    overflow: hidden;
+    background: $background 60%;
+    align-horizontal: right;
+
+    &.-narrow #contents {
+        width: 1fr;
+    }
+
+    #contents {
+        width: 50%;
+        padding: 0 1;    
+        background: black 10%;                    
+        & > VerticalScroll {
+            overflow: hidden scroll;
+        }
+    }
+
+    #settings-container {
+        layout: stream;     
+    }
+
+    .hidden {
+        display: none;
+    }
+
+    .setting:last-child .input {        
+        margin: 1 0 0 0;        
+    }
+
+    Input,Select SelectCurrent, Checkbox,TextArea {
+        border: tall black 20%;
+        &:focus {
+            border: tall $primary;
+        }
+    }
+    Select:focus > SelectCurrent {        
+        border: tall $primary;        
+    }
+
+    .input {
+        margin: 1 0 1 0;        
+    }
+
+    Input.-invalid {
+        border: tall $error 60%;
+    }
+
+    TextArea {
+        height: 10;
+    }
+
+    .search-container {
+        dock: top;
+        padding: 1 0;
+    }
+    
+    .setting-group {
+        padding: 0;    
+        & > .setting-object:last-child {            
+            margin-bottom: 0;            
+        }
+    }
+
+    .setting-object {        
+        border: tall $secondary-muted;
+        &:light {
+            border: tall $foreground 20%;
+        }   
+        padding: 0 1;
+        
+        &:focus-within {
+            border: tall $secondary;         
+        }
+        .heading {
+            margin-bottom: 1;
+        }
+        margin-bottom: 1;
+                
+        &:last-child {
+            margin: 0 0 0 0;             
+        }
+        .heading .title {
+            color: $primary;
+            text-style: none;
+        }             
+    }
+
+    .title {
+        margin: 0;        
+        padding: 0 0 0 1;
+        text-style: bold;
+    }
+    .help {
+        color: $text-muted;        
+        padding: 0 0 0 1;
+    }
+
+}
+