open-data-sci 0.1.0__py3-none-any.whl

opendatasci/_tui/file_refs.py

@@ -0,0 +1,153 @@
+"""File-reference parsing for the @path/to/file syntax in user input."""
+
+import re
+import time
+from pathlib import Path
+
+from rich.markup import escape as escape_markup
+
+# Matches @path/to/file  or  @Makefile  or  @.env
+_FILE_REF_RE = re.compile(r"@(\S+?)(?=\s|$)")
+
+
+class _FileRef:
+    """A @file reference parsed from user input."""
+
+    def __init__(self, path: str) -> None:
+        self._path = path
+
+    @property
+    def display_name(self) -> str:
+        return Path(self._path).name
+
+
+def _parse_file_refs(text: str) -> tuple[str, list[_FileRef]]:
+    """Return (text_without_refs, list_of_refs)."""
+    refs = [_FileRef(path=m.group(1)) for m in _FILE_REF_RE.finditer(text)]
+    clean = _FILE_REF_RE.sub("", text).strip()
+    return clean, refs
+
+
+def _build_user_display(clean_text: str, refs: list[_FileRef]) -> str:
+    """Build the Rich-markup string shown in the user bubble."""
+    parts = []
+    for ref in refs:
+        parts.append(rf"[bold #58a6ff]\[{ref.display_name}][/bold #58a6ff]")
+    if clean_text:
+        parts.append(escape_markup(clean_text))
+    return "\n".join(parts)
+
+
+def _build_agent_query(clean_text: str, refs: list[_FileRef]) -> str:
+    """Build the query string sent to the agent, with file attachment tags."""
+    if not refs:
+        return clean_text
+    parts = [clean_text] if clean_text else []
+    for ref in refs:
+        abs_path = str(Path(ref._path).resolve())
+        parts.append(f'<file_attachment path="{abs_path}" name="{ref.display_name}"/>')
+    return "\n\n".join(parts)
+
+
+def _split_existing_file_refs(refs: list[_FileRef]) -> tuple[list[_FileRef], list[_FileRef]]:
+    """Split refs into (existing_files, missing_or_invalid)."""
+    existing: list[_FileRef] = []
+    missing: list[_FileRef] = []
+    for ref in refs:
+        path = Path(ref._path).expanduser()
+        if path.exists() and path.is_file():
+            existing.append(ref)
+        else:
+            missing.append(ref)
+    return existing, missing
+
+
+def _find_slash_fragment(text: str) -> str | None:
+    """Return the slash fragment if text starts with / and has no space yet."""
+    if text.startswith("/") and " " not in text:
+        return text
+    return None
+
+
+def _find_at_fragment(text: str) -> tuple[str, int] | None:
+    """Return (fragment, at_index) for the last active @-reference being typed, or None."""
+    at_pos = text.rfind("@")
+    if at_pos == -1:
+        return None
+    after = text[at_pos + 1 :]
+    space_pos = after.find(" ")
+    fragment = after[:space_pos] if space_pos != -1 else after
+    return fragment, at_pos
+
+
+_DIR_CACHE_TTL = 2.0
+# Maps str(search_dir) → (timestamp, [(name, is_dir), ...])
+_dir_cache: dict[str, tuple[float, list[tuple[str, bool]]]] = {}
+
+
+def _discover_files(fragment: str) -> list[str]:
+    """Return up to 10 file/dir paths under cwd that match the typed fragment."""
+    frag = fragment.replace("\\", "/")
+    if "/" in frag:
+        dir_part, name_prefix = frag.rsplit("/", 1)
+        search_dir = Path(dir_part) if Path(dir_part).is_absolute() else Path.cwd() / dir_part
+    else:
+        dir_part = ""
+        name_prefix = frag
+        search_dir = Path.cwd()
+
+    if not search_dir.is_dir():
+        return []
+
+    cache_key = str(search_dir)
+    now = time.monotonic()
+    cached = _dir_cache.get(cache_key)
+    if cached is None or now - cached[0] > _DIR_CACHE_TTL:
+        try:
+            entries: list[tuple[str, bool]] = [
+                (e.name, e.is_dir()) for e in sorted(search_dir.iterdir())
+            ]
+        except (PermissionError, OSError):
+            return []
+        _dir_cache[cache_key] = (now, entries)
+    else:
+        entries = cached[1]
+
+    show_hidden = name_prefix.startswith(".")
+    matches: list[str] = []
+    for name, is_dir in entries:
+        if name.startswith(".") and not show_hidden:
+            continue
+        if name_prefix and not name.lower().startswith(name_prefix.lower()):
+            continue
+        rel = (dir_part + "/" + name) if dir_part else name
+        if is_dir:
+            rel += "/"
+        matches.append(rel)
+
+    return matches[:10]
+
+
+class PasteAttachment:
+    """Multi-line text pasted by the user, shown as a compact pill in the UI.
+
+    The LLM receives the full content inside ``<pasted_content>`` tags;
+    the user sees only the pill label in the attachment bar.
+    """
+
+    def __init__(self, content: str) -> None:
+        self._content = content
+        self._line_count = content.count("\n") + 1
+
+    @property
+    def display_label(self) -> str:
+        n = self._line_count
+        return f"Text: {n} line{'s' if n != 1 else ''}"
+
+    @property
+    def pill_markup(self) -> str:
+        return rf"[bold #58a6ff]\[{escape_markup(self.display_label)}][/bold #58a6ff]"
+
+    @property
+    def xml_tag(self) -> str:
+        return f"<pasted_content>\n{self._content}\n</pasted_content>"

opendatasci/_tui/models.py

@@ -0,0 +1,4 @@
+"""Data models and UI constants for OpenDataSci TUI."""
+
+SPINNER = "⣾⣽⣻⢿⡿⣟⣯⣷"
+SPINNER_INTERVAL = 0.12

opendatasci/_tui/presenter.py

@@ -0,0 +1,259 @@
+"""_TurnPresenter — manages all UI state for a single agent-turn stream.
+
+Extracted from ``CLIController.run_agent`` to reduce its complexity.
+``CLIController`` creates one ``_TurnPresenter`` per turn, feeds it events,
+and calls ``cleanup()`` in the ``finally`` block.
+"""
+
+import logging
+import time
+
+from opendatasci.streaming.events import (
+    ErrorEvent,
+    ReasoningEvent,
+    ResponseEvent,
+    SubagentEvent,
+    TokenEvent,
+    ToolCallEvent,
+    ToolCommunicationEvent,
+    ToolResultEvent,
+    UsageEvent,
+    WorkerDoneEvent,
+)
+from opendatasci.tools import ToolName
+
+from .adapter import EphemeralHandle, MessageHandle, ThinkingHandle, TurnStatusHandle, UIAdapter
+from .tools_display import REGISTRY, ToolDisplay
+
+logger = logging.getLogger(__name__)
+
+
+class _TurnPresenter:
+    """Manages ephemeral UI state (bubbles, tool blocks, thinking) for one turn.
+
+    All methods are synchronous; awaiting happens inside ``MessageBubble``
+    and ``ToolCallBlock`` via Textual's own async machinery.
+    """
+
+    def __init__(self, ui: UIAdapter) -> None:
+        self._ui = ui
+        self._agent_msg: MessageHandle | None = None
+        self._thinking_start: float = 0.0
+        self._had_reasoning: bool = False
+        self._ephemerals: list[EphemeralHandle] = []
+        # tool_call_id → ephemeral (promoted once tool_call fires)
+        self._ephemerals_by_id: dict[str, EphemeralHandle] = {}
+        # Ephemerals created from leading tool_communication before tool_call fires
+        self._pending_ephemerals: dict[str, EphemeralHandle] = {}
+        self._worker_block: EphemeralHandle | None = None
+        # tool_call_id → latest communication text (buffered until block is ready)
+        self._comm_buffers: dict[str, str] = {}
+        # tool_call_ids for tools with display=False — no UI created, result silently ignored
+        self._hidden_tool_call_ids: set[str] = set()
+        # Ephemeral "Thinking..." spinner shown while the LLM is processing
+        self._thinking_block: ThinkingHandle | None = None
+        self._show_thinking_block()
+
+    # ── Internal helpers ──────────────────────────────────────────────────────
+
+    def _show_thinking_block(self) -> None:
+        if self._thinking_block is None:
+            self._thinking_block = self._ui.add_thinking_block()
+            self._had_reasoning = False
+
+    def _dismiss_thinking_block(self) -> None:
+        if self._thinking_block is not None:
+            self._thinking_block.dismiss()
+            self._thinking_block = None
+
+    def _finish_thinking(self) -> None:
+        if self._thinking_block is None:
+            return
+        if self._had_reasoning:
+            elapsed = int(time.monotonic() - self._thinking_start)
+            self._thinking_block.finish(f"Thought for {elapsed}s")
+        else:
+            self._thinking_block.dismiss()
+        self._thinking_block = None
+
+    @staticmethod
+    def _make_label(tool_display: ToolDisplay | None, event: ToolCallEvent) -> str:
+        icon = tool_display.icon if tool_display else ""
+        label_text = (tool_display.label if tool_display else None) or event.tool.replace(
+            "_", " "
+        ).title()
+        return f"{icon} {label_text}".strip() if icon else label_text
+
+    @staticmethod
+    def _make_summary(tool_display: ToolDisplay | None, event: ToolCallEvent) -> str:
+        icon = tool_display.icon if tool_display else ""
+        return f"{icon} {event.summary}".strip() if (icon and event.summary) else event.summary
+
+    # ── Event handlers ────────────────────────────────────────────────────────
+
+    def handle_reasoning(self, event: ReasoningEvent) -> None:
+        if not self._had_reasoning:
+            self._thinking_start = time.monotonic()
+            self._had_reasoning = True
+
+    def handle_token(self, event: TokenEvent) -> None:
+        self._finish_thinking()
+        if self._agent_msg is None:
+            self._agent_msg = self._ui.add_message("agent", "")
+        self._agent_msg.append(event.content)
+
+    def handle_tool_communication(self, event: ToolCommunicationEvent) -> None:
+        self._finish_thinking()
+        tc_id = event.tool_call_id
+        comm = event.content
+        self._comm_buffers[tc_id] = comm
+
+        if tc_id and tc_id in self._ephemerals_by_id:
+            target = self._ephemerals_by_id[tc_id]
+            if target.is_running():
+                target.set_communication(comm)
+        elif tc_id and tc_id not in self._ephemerals_by_id:
+            # First comm token — pre-mount a placeholder ephemeral.
+            block = self._ui.add_ephemeral_block(comm, "…", "")
+            self._pending_ephemerals[tc_id] = block
+            self._ephemerals.append(block)
+            self._ephemerals_by_id[tc_id] = block
+
+    def handle_tool_call(self, event: ToolCallEvent) -> None:
+        tool_call_id = event.tool_call_id or ""
+        existing = self._pending_ephemerals.pop(tool_call_id, None) if tool_call_id else None
+        tool_display = REGISTRY.get(str(event.tool))
+
+        if tool_display is not None and not tool_display.display:
+            # Tool is hidden — discard any pending comm block and never create a new one.
+            if existing is not None:
+                existing.dismiss()
+                self._ephemerals = [e for e in self._ephemerals if e is not existing]
+                self._ephemerals_by_id.pop(tool_call_id, None)
+            self._comm_buffers.pop(tool_call_id, None)
+            if tool_call_id:
+                self._hidden_tool_call_ids.add(tool_call_id)
+            return
+
+        self._finish_thinking()
+        has_narration = self._agent_msg is not None
+        if self._agent_msg is not None:
+            self._agent_msg.finish()
+            self._agent_msg = None
+
+        buffered_comm = self._comm_buffers.pop(tool_call_id, "")
+        comm = "" if has_narration else buffered_comm
+
+        if str(event.tool) == ToolName.SPAWN_WORKERS:
+            if existing is not None:
+                existing.dismiss()
+                self._ephemerals = [e for e in self._ephemerals if e is not existing]
+                self._ephemerals_by_id.pop(tool_call_id, None)
+            block = self._ui.add_worker_block(comm, list(event.worker_summaries))
+            self._worker_block = block
+            self._ephemerals.append(block)
+            if tool_call_id:
+                self._ephemerals_by_id[tool_call_id] = block
+        elif existing is not None:
+            if has_narration:
+                existing.set_communication(None)
+            existing.upgrade(
+                self._make_label(tool_display, event), self._make_summary(tool_display, event)
+            )
+        else:
+            block = self._ui.add_ephemeral_block(
+                comm, self._make_label(tool_display, event), self._make_summary(tool_display, event)
+            )
+            self._ephemerals.append(block)
+            if tool_call_id:
+                self._ephemerals_by_id[tool_call_id] = block
+
+    def handle_worker_done(self, event: WorkerDoneEvent) -> None:
+        if self._worker_block is not None and event.worker_idx is not None:
+            if event.success:
+                self._worker_block.mark_worker_done(event.worker_idx)
+            else:
+                self._worker_block.mark_worker_error(event.worker_idx)
+
+    def handle_subagent_event(self, event: SubagentEvent) -> None:
+        if self._worker_block is None or event.worker_idx is None:
+            return
+        if event.event_type == "worker_tool_call":
+            tool_name = event.content
+            tool_display = REGISTRY.get(tool_name)
+            activity = event.summary
+            icon = tool_display.icon if tool_display else ""
+            if activity:
+                activity = f"{icon} {activity}".strip() if icon else activity
+            elif tool_display:
+                activity = f"{icon} {tool_display.label}".strip() if icon else tool_display.label
+            else:
+                activity = tool_name
+            self._worker_block.update_worker_activity(event.worker_idx, activity)
+        elif event.event_type == "worker_tool_result":
+            # Tool finished — drop the inline activity so the row reverts to the
+            # worker's subtask summary while the LLM decides on the next step.
+            self._worker_block.update_worker_activity(event.worker_idx, "")
+
+    def handle_tool_result(self, event: ToolResultEvent) -> None:
+        tool_call_id = event.tool_call_id
+        if tool_call_id and tool_call_id in self._hidden_tool_call_ids:
+            self._hidden_tool_call_ids.discard(tool_call_id)
+            return
+        if tool_call_id and tool_call_id in self._ephemerals_by_id:
+            target = self._ephemerals_by_id.pop(tool_call_id)
+            if event.is_error:
+                target.set_error()
+            else:
+                target.set_done()
+            self._ephemerals = [e for e in self._ephemerals if e is not target]
+        else:
+            logger.warning(
+                "Received uncorrelated tool_result (tool_call_id=%r); "
+                "leaving ephemerals running until cleanup",
+                tool_call_id,
+            )
+        self._show_thinking_block()
+
+    def handle_usage(self, event: UsageEvent, turn_status: TurnStatusHandle | None) -> None:
+        input_tokens = event.input_tokens
+        output_tokens = event.output_tokens
+        cache_read_tokens = event.cache_read_tokens
+
+        context_tokens: int | None = None
+        if input_tokens is not None or output_tokens is not None:
+            context_tokens = int(input_tokens or 0) + int(output_tokens or 0)
+
+        cached_tokens: int | None = (
+            int(cache_read_tokens) if cache_read_tokens is not None else None
+        )
+
+        if turn_status is not None:
+            turn_status.update_context(context_tokens, cached_tokens)
+
+    def handle_response(self, event: ResponseEvent) -> None:
+        self._finish_thinking()
+        if self._agent_msg is None and event.content:
+            self._agent_msg = self._ui.add_message("agent", event.content)
+
+    def handle_error(self, event: ErrorEvent) -> None:
+        self._dismiss_thinking_block()
+        if self._agent_msg is None:
+            self._agent_msg = self._ui.add_message("agent", "")
+        self._agent_msg.append(f"\n\n❌ {event.content}")
+
+    def handle_exception(self, exc: Exception) -> None:
+        self._dismiss_thinking_block()
+        if self._agent_msg is None:
+            self._agent_msg = self._ui.add_message("agent", "")
+        self._agent_msg.set_content(f"❌ **Error:** {exc}")
+
+    # ── Cleanup ───────────────────────────────────────────────────────────────
+
+    def cleanup(self) -> None:
+        """Finalise all open UI elements (called from the run_agent finally block)."""
+        self._finish_thinking()
+        for e in self._ephemerals:
+            e.set_done()
+        if self._agent_msg is not None:
+            self._agent_msg.finish()

opendatasci/_tui/service.py

@@ -0,0 +1,78 @@
+"""TUI service layer.
+
+``OpenDataSciTuiService``: the single service class used by ``CLIController``.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any, AsyncIterator
+
+from opendatasci.agents.agents import BaseOpenDataSciAgent
+from opendatasci.sandbox.base import BaseSandbox
+from opendatasci.streaming import AgentStreamEvent
+
+logger = logging.getLogger(__name__)
+
+
+class OpenDataSciTuiService:
+    """Service layer for the OpenDataSci TUI.
+
+    Owns the agent and sandbox for the lifetime of a terminal session.
+    Create a new instance for each file or workspace loaded by the TUI.
+    """
+
+    def __init__(
+        self,
+        agent: BaseOpenDataSciAgent,
+        sandbox: BaseSandbox,
+        workspace_path: Path | None = None,
+    ) -> None:
+        self._agent = agent
+        self._sandbox = sandbox
+        self._workspace_path = workspace_path
+
+    async def __aenter__(self) -> "OpenDataSciTuiService":
+        return self
+
+    async def __aexit__(self, *_: Any) -> None:
+        await self.close()
+
+    async def close(self) -> None:
+        """Release sandbox resources (e.g. stop Docker containers)."""
+        await self._sandbox.close()
+
+    async def astream(self, query: str) -> AsyncIterator[AgentStreamEvent]:
+        """Stream events for *query* with token-level output."""
+        async for event in self._agent.astream(query):
+            yield event
+
+    async def reset_session(self) -> None:
+        """Reset the execution session and clear agent conversation."""
+        self._sandbox.reset()
+        await self._agent.clear_chat_history()
+
+    async def clear_context(self) -> None:
+        """Clear all agent context: conversation history and memory summaries."""
+        await self._agent.clear_chat_history()
+
+    async def rewind_turn(self) -> None:
+        """Remove the last turn from the conversation history."""
+        await self._agent.rewind_turn()
+
+    async def compact_chat_history(self) -> str:
+        """Compact the conversation history and return the summary."""
+        return await self._agent.compact_chat_history()
+
+    def get_workspace_files(self) -> list[str]:
+        """Return names of files/dirs visible in the workspace, relative to its root.
+
+        Used by the /ls-workspace command.
+        """
+        if self._workspace_path is None:
+            return []
+        path = self._workspace_path
+        try:
+            entries = sorted(path.iterdir(), key=lambda f: (f.is_dir(), f.name.lower()))
+            return [e.name + ("/" if e.is_dir() else "") for e in entries]
+        except Exception:
+            return []

opendatasci/_tui/session.py

@@ -0,0 +1,53 @@
+"""CLISessionInfo: boot-time metadata consumed only by CLIController."""
+
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+from opendatasci._utils.data_formats import ALL_SUPPORTED_EXTENSIONS
+from opendatasci.configs import OpenDataSciConfig
+
+
+class CLISessionInfo(BaseModel):
+    """Metadata about a loaded session."""
+
+    path: str
+    is_directory: bool
+    workspace_count: int
+    workspaces: list[dict[str, Any]]
+    provider: str
+    model: str | None
+
+    @classmethod
+    def from_path(
+        cls,
+        path: str,
+        workspace_path: Path | None,
+        config: OpenDataSciConfig,
+    ) -> "CLISessionInfo":
+        file_path = Path(path)
+        is_dir = file_path.is_dir()
+
+        if is_dir and workspace_path is not None:
+            data_files = [
+                f
+                for f in workspace_path.rglob("*")
+                if f.is_file()
+                and f.suffix in ALL_SUPPORTED_EXTENSIONS
+                and not any(part.startswith(".") for part in f.relative_to(workspace_path).parts)
+            ]
+            workspaces = [{"name": f.name} for f in data_files]
+            workspace_count = len(data_files)
+        else:
+            workspaces = [{"name": file_path.name}]
+            workspace_count = 1
+
+        return cls(
+            path=path,
+            is_directory=is_dir,
+            workspace_count=workspace_count,
+            workspaces=workspaces,
+            provider=config.provider,
+            model=config.model,
+        )