ommlds 0.0.0.dev466__py3-none-any.whl → 0.0.0.dev512__py3-none-any.whl

ommlds/cli/sessions/chat/interfaces/textual/inputhistory.py

@@ -0,0 +1,174 @@
+import abc
+import json
+import os
+import typing as ta
+
+from omlish import lang
+
+
+##
+
+
+class InputHistoryStorage(lang.Abstract):
+    @abc.abstractmethod
+    def load(self) -> list[str]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def save(self, entries: ta.Sequence[str]) -> None:
+        raise NotImplementedError
+
+
+class InMemoryInputHistoryStorage(InputHistoryStorage):
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._entries: list[str] = []
+
+    def load(self) -> list[str]:
+        return list(self._entries)
+
+    def save(self, entries: ta.Sequence[str]) -> None:
+        self._entries = list(entries)
+
+
+class FileInputHistoryStorage(InputHistoryStorage):
+    def __init__(self, *, path: str) -> None:
+        super().__init__()
+
+        self._path = path
+
+    def load(self) -> list[str]:
+        if not os.path.exists(self._path):
+            return []
+
+        try:
+            with open(self._path) as f:
+                data = json.load(f)
+                if isinstance(data, list) and all(isinstance(e, str) for e in data):
+                    return data
+                return []
+        except (json.JSONDecodeError, OSError):
+            return []
+
+    def save(self, entries: ta.Sequence[str]) -> None:
+        try:
+            dir_path = os.path.dirname(self._path)
+            if dir_path:
+                os.makedirs(dir_path, exist_ok=True)
+            with open(self._path, 'w') as f:
+                json.dump(list(entries), f, indent=2)
+        except OSError:
+            pass
+
+
+##
+
+
+class InputHistoryManager:
+    """
+    Manages input history with readline-style navigation.
+
+    History position semantics:
+    - Position starts at len(history) (one past the end)
+    - Moving 'previous' decrements position
+    - Moving 'next' increments position
+    - Position is clamped to [0, len(history)]
+    - Position len(history) represents 'no history item selected'
+    """
+
+    def __init__(
+            self,
+            *,
+            storage: InputHistoryStorage,
+            max_entries: int = 1000,
+    ) -> None:
+        super().__init__()
+
+        self._storage = storage
+        self._max_entries = max_entries
+
+        self._entries: list[str] = self._storage.load()
+        self._position: int = len(self._entries)
+        self._current_draft: str = ''
+
+    def add(self, text: str) -> None:
+        """Add a new history entry and reset position."""
+
+        if not text.strip():
+            return
+
+        # Don't add duplicate consecutive entries
+        if self._entries and self._entries[-1] == text:
+            self.reset_position()
+            return
+
+        self._entries.append(text)
+
+        # Trim to max size
+        if len(self._entries) > self._max_entries:
+            self._entries = self._entries[-self._max_entries:]
+
+        self._storage.save(self._entries)
+        self.reset_position()
+
+    def get_previous(self, text: str | None = None) -> str | None:
+        """
+        Navigate to previous (older) history entry.
+
+        Args:
+            text: Current text in the input field (saved as draft when at end of history)
+
+        Returns:
+            The previous history entry, or None if at the beginning
+        """
+
+        if not self._entries:
+            return None
+
+        # Save current draft if we're at the end
+        if self._position == len(self._entries) and text is not None:
+            self._current_draft = text
+
+        # Move to previous entry
+        if self._position > 0:
+            self._position -= 1
+            return self._entries[self._position]
+
+        # Already at oldest entry
+        return self._entries[0] if self._entries else None
+
+    def get_next(self, text: str | None = None) -> str | None:
+        """
+        Navigate to next (newer) history entry.
+
+        Args:
+            text: Current text in the input field (unused for now)
+
+        Returns:
+            The next history entry, the saved draft if moving past the end, or None
+        """
+
+        if not self._entries:
+            return None
+
+        # Move to next entry
+        if self._position < len(self._entries):
+            self._position += 1
+
+            # If we moved past the end, return the draft
+            if self._position == len(self._entries):
+                draft = self._current_draft
+                self._current_draft = ''
+                return draft
+
+            return self._entries[self._position]
+
+        # Already at newest position
+        return None
+
+    def reset_position(self) -> None:
+        """Reset history position to the end (no history item selected)."""
+
+        self._position = len(self._entries)
+        self._current_draft = ''

ommlds/cli/sessions/chat/interfaces/textual/interface.py

@@ -0,0 +1,24 @@
+from omdev.tui import textual as tx
+
+from ..base import ChatInterface
+from .app import ChatApp
+
+
+##
+
+
+class TextualChatInterface(ChatInterface):
+    def __init__(
+            self,
+            *,
+            app: ChatApp,
+    ) -> None:
+        super().__init__()
+
+        self._app = app
+
+    async def run(self) -> None:
+        # FIXME: move lol
+        tx.set_root_logger_to_devtools(self._app.devtools)
+
+        await self._app.run_async()

ommlds/cli/sessions/chat/interfaces/textual/styles/__init__.py

@@ -0,0 +1,29 @@
+import io as _io
+
+from omlish import lang as _lang
+
+
+##
+
+
+@_lang.cached_function
+def read_app_css() -> str:
+    tcss_rsrcs = [
+        rsrc
+        for rsrc in _lang.get_relative_resources(globals=globals()).values()
+        if rsrc.name.endswith('.tcss')
+    ]
+
+    out = _io.StringIO()
+
+    for i, rsrc in enumerate(tcss_rsrcs):
+        if i:
+            out.write('\n\n')
+
+        out.write(f'/*** {rsrc.name} ***/\n')
+        out.write('\n')
+
+        out.write(rsrc.read_text().strip())
+        out.write('\n')
+
+    return out.getvalue()

ommlds/cli/sessions/chat/interfaces/textual/styles/input.tcss

@@ -0,0 +1,53 @@
+#input-outer {
+    width: 100%;
+    height: auto;
+
+    background: $background-darken-3;
+}
+
+#input-vertical {
+    width: 100%;
+    height: auto;
+
+    margin: 0 1 1 1;
+
+    padding: 0;
+}
+
+#input-vertical2 {
+    width: 100%;
+    height: auto;
+
+    border: round $foreground-muted;
+
+    padding: 0 1;
+}
+
+#input-horizontal {
+    width: 100%;
+    height: auto;
+}
+
+#input-glyph {
+    width: auto;
+
+    padding: 0 1 0 0;
+
+    background: transparent;
+    color: $primary;
+
+    text-style: bold;
+}
+
+#input {
+    width: 1fr;
+    height: auto;
+    max-height: 16;
+
+    border: none;
+
+    padding: 0;
+
+    background: transparent;
+    color: $text;
+}

ommlds/cli/sessions/chat/interfaces/textual/styles/markdown.tcss

@@ -0,0 +1,7 @@
+Markdown MarkdownFence {
+    max-width: 95%;
+
+    overflow-x: auto;
+
+    scrollbar-size-horizontal: 1;
+}

ommlds/cli/sessions/chat/interfaces/textual/styles/messages.tcss

@@ -0,0 +1,167 @@
+/* Container */
+
+#messages-container {
+    width: 100%;
+    height: 1fr;
+
+    scrollbar-gutter: stable;
+
+    background: $background-darken-3;
+
+    text-align: left;
+
+    scrollbar-size: 1 1;
+}
+
+
+/* Divider */
+
+.message-divider {
+    height: 1;
+    margin: 1 0 0 0;
+
+    border-top: solid $primary;
+}
+
+
+/* Base Message */
+
+.message {
+    width: 1fr;
+    height: auto;
+
+    margin: 1 0 0 0;
+
+    padding-right: 1;
+
+    layout: stream;
+}
+
+.message-glyph {
+    width: auto;
+    height: auto;
+
+    background: transparent;
+    color: $primary;
+
+    text-style: bold;
+}
+
+.message-outer {
+    width: 1fr;
+    height: auto;
+
+    align: left top;
+}
+
+.message-inner {
+    width: 1fr;
+    height: auto;
+}
+
+
+/* Welcome Message */
+
+.welcome-message {
+    margin: 0;
+
+    padding: 1 2 1 1;
+
+    border: round;
+}
+
+.welcome-message-outer {
+}
+
+.welcome-message-content {
+}
+
+
+/* User Message */
+
+.user-message {
+}
+
+.user-message-outer {
+}
+
+.user-message-glyph {
+}
+
+.user-message-inner {
+}
+
+
+/* Ai Message */
+
+.ai-message {
+}
+
+.ai-message-outer {
+}
+
+.ai-message-glyph {
+}
+
+.ai-message-inner {
+    padding: 0;
+
+    Markdown {
+        width: 100%;
+        height: auto;
+
+        margin: 0;
+        padding: 0;
+    }
+}
+
+
+/* Tool Confirmation Message */
+
+.tool-confirmation-message {
+}
+
+.tool-confirmation-message-outer {
+}
+
+.tool-confirmation-message-glyph {
+}
+
+.tool-confirmation-message-inner {
+}
+
+.tool-confirmation-message-inner-open {
+    background: $warning-lighten-3 15%;
+}
+
+.tool-confirmation-message-inner-closed {
+}
+
+.tool-confirmation-message-outer-content {
+}
+
+.tool-confirmation-message-inner-content {
+    background: $background;
+
+    margin: 1;
+    padding: 1;
+}
+
+.tool-confirmation-message-controls {
+    margin: 1;
+}
+
+
+/* Ui Message */
+
+.ui-message {
+}
+
+.ui-message-glyph {
+}
+
+.ui-message-outer {
+}
+
+.ui-message-inner {
+}

ommlds/cli/sessions/chat/interfaces/textual/tools.py

@@ -0,0 +1,38 @@
+from omlish.formats import json
+
+from ...... import minichain as mc
+from ...drivers.tools.confirmation import ToolExecutionConfirmation
+from ...drivers.tools.confirmation import ToolExecutionRequestDeniedError
+from .app import ChatAppGetter
+
+
+##
+
+
+class ChatAppToolExecutionConfirmation(ToolExecutionConfirmation):
+    def __init__(
+            self,
+            *,
+            app: ChatAppGetter,
+    ) -> None:
+        super().__init__()
+
+        self._app = app
+
+    async def confirm_tool_execution_or_raise(
+            self,
+            use: 'mc.ToolUse',
+            entry: 'mc.ToolCatalogEntry',
+    ) -> None:
+        tr_dct = dict(
+            id=use.id,
+            name=entry.spec.name,
+            args=use.args,
+            # spec=msh.marshal(tce.spec),
+        )
+
+        if not await (await self._app()).confirm_tool_use(
+                'Execute requested tool?',
+                json.dumps_pretty(tr_dct),
+        ):
+            raise ToolExecutionRequestDeniedError

ommlds/cli/sessions/chat/interfaces/textual/widgets/input.py

@@ -0,0 +1,70 @@
+import dataclasses as dc
+import typing as ta
+
+from omdev.tui import textual as tx
+
+
+##
+
+
+class InputTextArea(tx.TextArea):
+    @dc.dataclass()
+    class Submitted(tx.Message):
+        text: str
+
+    @dc.dataclass()
+    class HistoryPrevious(tx.Message):
+        text: str
+
+    @dc.dataclass()
+    class HistoryNext(tx.Message):
+        text: str
+
+    @dc.dataclass()
+    class HistoryReset(tx.Message):
+        pass
+
+    def __init__(self, **kwargs: ta.Any) -> None:
+        super().__init__(**kwargs)
+
+    BINDINGS: ta.ClassVar[ta.Sequence[tx.Binding]] = [  # type: ignore[assignment]
+        tx.Binding(
+            'enter',
+            'submit',
+            priority=True,
+        ),
+        tx.Binding(
+            'ctrl+p',
+            'history_previous',
+        ),
+        tx.Binding(
+            'ctrl+n',
+            'history_next',
+        ),
+    ]
+
+    def action_submit(self) -> None:
+        if text := self.text.strip():
+            self.post_message(self.Submitted(text))
+
+    def action_cursor_up(self, select: bool = False) -> None:
+        # FIXME: if empty -> history_previous
+        super().action_cursor_up(select=select)
+
+    def action_cursor_down(self, select: bool = False) -> None:
+        super().action_cursor_down(select=select)
+
+    def action_history_previous(self) -> None:
+        self.post_message(self.HistoryPrevious(self.text))
+
+    def action_history_next(self) -> None:
+        self.post_message(self.HistoryNext(self.text))
+
+
+class InputOuter(tx.Static):
+    def compose(self) -> tx.ComposeResult:
+        with tx.Vertical(id='input-vertical'):
+            with tx.Vertical(id='input-vertical2'):
+                with tx.Horizontal(id='input-horizontal'):
+                    yield tx.Static('>', id='input-glyph')
+                    yield InputTextArea(placeholder='...', id='input')