dlab-cli 0.1.0__py3-none-any.whl

dlab/tui/log_watcher.py

@@ -0,0 +1,208 @@
+"""
+Log file watcher using simple polling.
+
+Tracks file positions and streams new log events as they are appended.
+"""
+
+import json
+import threading
+from pathlib import Path
+from queue import Queue
+from typing import Any, Callable
+
+
+class LogWatcher:
+    """
+    Watches log directory for changes via periodic polling.
+
+    Simple and reliable approach - polls all log files for new content.
+    Called periodically from the UI update timer.
+    """
+
+    def __init__(self, logs_dir: Path) -> None:
+        """
+        Initialize watcher.
+
+        Parameters
+        ----------
+        logs_dir : Path
+            Directory containing log files.
+        """
+        self._logs_dir = logs_dir
+        self._event_queue: Queue[tuple[str, dict[str, Any]]] = Queue()
+        self._file_positions: dict[Path, int] = {}
+        self._file_inodes: dict[Path, int] = {}  # Track inode for replacement detection
+        self._lock = threading.Lock()
+        self._running = False
+
+    def _get_source_name(self, log_path: Path) -> str:
+        """
+        Convert log path to source name.
+
+        Parameters
+        ----------
+        log_path : Path
+            Path to log file.
+
+        Returns
+        -------
+        str
+            Source name (e.g., "main", "instance-1").
+        """
+        try:
+            rel_path = log_path.relative_to(self._logs_dir)
+            if len(rel_path.parts) > 1:
+                return f"{rel_path.parent.name}/{rel_path.stem}"
+            return rel_path.stem
+        except ValueError:
+            return log_path.stem
+
+    def _read_new_lines(self, log_path: Path) -> list[tuple[str, dict[str, Any]]]:
+        """
+        Read new lines from a log file.
+
+        Handles atomic file replacement (common in Docker) by detecting:
+        - File inode changed (new file with same name)
+        - File size smaller than stored position (truncation)
+
+        Parameters
+        ----------
+        log_path : Path
+            Path to log file.
+
+        Returns
+        -------
+        list[tuple[str, dict[str, Any]]]
+            List of (source, event) tuples.
+        """
+        if not log_path.exists() or log_path.suffix != ".log":
+            return []
+
+        source = self._get_source_name(log_path)
+        events: list[tuple[str, dict[str, Any]]] = []
+
+        with self._lock:
+            position = self._file_positions.get(log_path, 0)
+            old_inode = self._file_inodes.get(log_path, 0)
+
+            try:
+                stat = log_path.stat()
+                current_size = stat.st_size
+                current_inode = stat.st_ino
+
+                # Detect file replacement or truncation:
+                # - Inode changed = file was atomically replaced (temp + rename)
+                # - Size < position = file was truncated
+                if current_inode != old_inode or current_size < position:
+                    # File was replaced - start from beginning
+                    position = 0
+
+                with open(log_path, "r") as f:
+                    f.seek(position)
+                    new_content = f.read()
+                    new_position = f.tell()
+
+                self._file_positions[log_path] = new_position
+                self._file_inodes[log_path] = current_inode
+
+                # Track consecutive raw text lines to group them
+                raw_text_lines: list[str] = []
+
+                def flush_raw_text() -> None:
+                    """Flush accumulated raw text lines as a single event."""
+                    if raw_text_lines:
+                        event = {
+                            "type": "raw_text",
+                            "timestamp": None,
+                            "part": {"text": "\n".join(raw_text_lines)},
+                        }
+                        events.append((source, event))
+                        raw_text_lines.clear()
+
+                for line in new_content.splitlines():
+                    line = line.strip()
+                    if not line:
+                        continue
+
+                    # Try to parse as JSON
+                    if line.startswith("{"):
+                        try:
+                            event = json.loads(line)
+                            # Flush any accumulated raw text first
+                            flush_raw_text()
+                            # Handle raw JSON outputs (no type/timestamp) as "additional_output"
+                            if not event.get("type") or not event.get("timestamp"):
+                                # Create a synthetic event for raw output
+                                event = {
+                                    "type": "additional_output",
+                                    "timestamp": None,
+                                    "part": {"raw_data": event},
+                                }
+                            events.append((source, event))
+                        except json.JSONDecodeError:
+                            # JSON-like but malformed - treat as raw text
+                            raw_text_lines.append(line)
+                    else:
+                        # Not JSON - accumulate as raw text
+                        raw_text_lines.append(line)
+
+                # Flush any remaining raw text
+                flush_raw_text()
+
+            except (IOError, OSError):
+                pass
+
+        return events
+
+    def start(self) -> None:
+        """
+        Start watching - reads all existing log files.
+        """
+        if self._running:
+            return
+
+        # Read existing content
+        for log_path in self._logs_dir.rglob("*.log"):
+            for source, event in self._read_new_lines(log_path):
+                self._event_queue.put((source, event))
+
+        self._running = True
+
+    def stop(self) -> None:
+        """Stop watching."""
+        self._running = False
+
+    def poll(self) -> None:
+        """
+        Poll all log files for new content.
+
+        Should be called periodically from the UI update timer.
+        """
+        if not self._running:
+            return
+
+        for log_path in self._logs_dir.rglob("*.log"):
+            for source, event in self._read_new_lines(log_path):
+                self._event_queue.put((source, event))
+
+    def get_events(self) -> list[tuple[str, dict[str, Any]]]:
+        """
+        Get all pending events from queue (non-blocking).
+
+        Returns
+        -------
+        list[tuple[str, dict[str, Any]]]
+            List of (source_name, event_dict) tuples.
+        """
+        events: list[tuple[str, dict[str, Any]]] = []
+        while not self._event_queue.empty():
+            try:
+                events.append(self._event_queue.get_nowait())
+            except Exception:
+                break
+        return events
+
+    @property
+    def is_running(self) -> bool:
+        """Whether watcher is currently running."""
+        return self._running

dlab/tui/models.py

@@ -0,0 +1,438 @@
+"""
+Data models for TUI state management.
+"""
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class LogEvent:
+    """
+    Parsed log event with computed fields.
+
+    Attributes
+    ----------
+    timestamp : int
+        Timestamp in milliseconds.
+    dt : datetime
+        Datetime object.
+    event_type : str
+        Event type (step_start, step_finish, text, tool_use).
+    source : str
+        Source agent/log name.
+    description : str
+        Human-readable description (truncated for display).
+    raw : dict[str, Any]
+        Original raw JSON data.
+    cost : float
+        Cost for this event (from step_finish).
+    duration_ms : int | None
+        Duration in milliseconds if applicable.
+    """
+
+    timestamp: int
+    dt: datetime
+    event_type: str
+    source: str
+    description: str
+    raw: dict[str, Any]
+    cost: float = 0.0
+    duration_ms: int | None = None
+
+    @property
+    def full_description(self) -> str:
+        """
+        Get full untruncated description from raw data.
+
+        Returns
+        -------
+        str
+            Full description without any truncation.
+        """
+        if self.event_type == "step_start":
+            return "Step started"
+
+        if self.event_type == "step_finish":
+            part = self.raw.get("part", {})
+            reason = part.get("reason", "unknown")
+            return f"Step finished ({reason})"
+
+        if self.event_type == "text":
+            part = self.raw.get("part", {})
+            return part.get("text", "")
+
+        if self.event_type == "raw_text":
+            part = self.raw.get("part", {})
+            return part.get("text", "")
+
+        if self.event_type == "error":
+            error_data = self.raw.get("error", {})
+            error_name = error_data.get("name", "Error")
+            data = error_data.get("data", {})
+            message = data.get("message", "Unknown error")
+            status_code = data.get("statusCode", "")
+            response_body = data.get("responseBody", "")
+
+            description = f"[{error_name}]"
+            if status_code:
+                description += f" (status: {status_code})"
+            description += f"\n{message}"
+            if response_body:
+                description += f"\n--- response ---\n{response_body}"
+            return description
+
+        if self.event_type == "tool_use":
+            part = self.raw.get("part", {})
+            tool = part.get("tool", "unknown")
+            state = part.get("state", {})
+            status = state.get("status", "unknown")
+            input_data = state.get("input", {})
+            output = state.get("output", "")
+
+            if tool == "bash":
+                cmd = input_data.get("command", "")
+                desc = input_data.get("description", "")
+                description = f"bash: {desc or cmd}"
+                if output:
+                    description += f"\n--- output ---\n{output}"
+                return description
+
+            if tool == "read":
+                filepath = input_data.get("filePath", "")
+                return f"read: {Path(filepath).name}"
+
+            if tool == "write":
+                filepath = input_data.get("filePath", "")
+                filename = Path(filepath).name
+                content = input_data.get("content", "")
+                description = f"write: {filename}"
+                if content:
+                    description += f"\n--- content ---\n{content}"
+                return description
+
+            if tool == "edit":
+                filepath = input_data.get("filePath", "")
+                old_string = input_data.get("oldString", "")
+                new_string = input_data.get("newString", "")
+                description = f"edit: {Path(filepath).name}"
+                if old_string or new_string:
+                    description += f"\n-{old_string}\n+{new_string}"
+                return description
+
+            if tool == "task":
+                subagent = input_data.get("subagent_type", "")
+                desc = input_data.get("description", "")
+                description = f"task: {subagent} - {desc}"
+                if output:
+                    description += f"\n--- output ---\n{output}"
+                return description
+
+            if tool == "parallel-agents":
+                agent = input_data.get("agent", "")
+                prompts = input_data.get("prompts", [])
+                description = f"parallel-agents: {agent} x{len(prompts)}"
+                if output:
+                    description += f"\n--- output ---\n{output}"
+                return description
+
+            # Generic tool - show everything for debugging
+            description = f"{tool} ({status})"
+            # Show input parameters
+            if input_data:
+                description += f"\n--- input ---\n"
+                for k, v in input_data.items():
+                    description += f"  {k}: {v}\n"
+            # Show error if present
+            error = state.get("error", "")
+            if error:
+                description += f"\n--- error ---\n{error}"
+            # Show output if present
+            if output:
+                description += f"\n--- output ---\n{output}"
+            return description
+
+        return self.description
+
+    @classmethod
+    def from_raw(cls, raw: dict[str, Any], source: str) -> "LogEvent":
+        """
+        Create LogEvent from raw JSON event data.
+
+        Parameters
+        ----------
+        raw : dict[str, Any]
+            Raw JSON event from log file.
+        source : str
+            Source name for this event.
+
+        Returns
+        -------
+        LogEvent
+            Parsed event.
+        """
+        timestamp = raw.get("timestamp")
+        # Handle None timestamp (for additional_output events)
+        if timestamp is None:
+            timestamp = 0  # Will be displayed specially
+            dt = datetime.min  # Sentinel — no real timestamp, won't affect duration
+        else:
+            dt = datetime.fromtimestamp(timestamp / 1000)
+        event_type = raw.get("type", "unknown")
+        part = raw.get("part", {})
+
+        # Build description based on event type
+        description = ""
+        cost = 0.0
+        duration_ms = None
+
+        if event_type == "additional_output":
+            # Raw JSON output from tool/script (not a proper OpenCode event)
+            raw_data = part.get("raw_data", {})
+            description = f"[output] {json.dumps(raw_data)}"
+
+        elif event_type == "raw_text":
+            # Raw text output (non-JSON lines from log)
+            description = part.get("text", "")
+
+        elif event_type == "step_start":
+            description = "Step started"
+
+        elif event_type == "step_finish":
+            reason = part.get("reason", "unknown")
+            description = f"Step finished ({reason})"
+            cost = part.get("cost", 0.0)
+
+        elif event_type == "text":
+            text = part.get("text", "")
+            description = text
+
+        elif event_type == "error":
+            error_data = raw.get("error", {})
+            error_name = error_data.get("name", "Error")
+            data = error_data.get("data", {})
+            message = data.get("message", "Unknown error")
+            status_code = data.get("statusCode", "")
+            response_body = data.get("responseBody", "")
+
+            description = f"[{error_name}]"
+            if status_code:
+                description += f" (status: {status_code})"
+            description += f"\n{message}"
+            if response_body:
+                description += f"\n--- response ---\n{response_body}"
+
+        elif event_type == "tool_use":
+            tool = part.get("tool", "unknown")
+            state = part.get("state", {})
+            status = state.get("status", "unknown")
+            input_data = state.get("input", {})
+            output = state.get("output", "")
+
+            if tool == "bash":
+                cmd = input_data.get("command", "")
+                desc = input_data.get("description", "")
+                description = f"bash: {desc or cmd}"
+                if output:
+                    description += f"\n--- output ---\n{output}"
+            elif tool == "read":
+                filepath = input_data.get("filePath", "")
+                description = f"read: {Path(filepath).name}"
+            elif tool == "write":
+                filepath = input_data.get("filePath", "")
+                filename = Path(filepath).name
+                content = input_data.get("content", "")
+                description = f"write: {filename}"
+                if content:
+                    description += f"\n--- content ---\n{content}"
+            elif tool == "edit":
+                filepath = input_data.get("filePath", "")
+                old_string = input_data.get("oldString", "")
+                new_string = input_data.get("newString", "")
+                description = f"edit: {Path(filepath).name}"
+                if old_string or new_string:
+                    description += f"\n-{old_string}\n+{new_string}"
+            elif tool == "task":
+                subagent = input_data.get("subagent_type", "")
+                desc = input_data.get("description", "")
+                description = f"task: {subagent} - {desc}"
+                if output:
+                    description += f"\n--- output ---\n{output}"
+            elif tool == "parallel-agents":
+                agent = input_data.get("agent", "")
+                prompts = input_data.get("prompts", [])
+                description = f"parallel-agents: {agent} x{len(prompts)}"
+                if output:
+                    description += f"\n--- output ---\n{output}"
+            else:
+                # Generic tool handling - show tool name, status, and any output/error
+                description = f"{tool} ({status})"
+                # Show input parameters
+                if input_data:
+                    description += f"\n--- input ---\n"
+                    for k, v in input_data.items():
+                        description += f"  {k}: {v}\n"
+                # Show error if present
+                error = state.get("error", "")
+                if error:
+                    description += f"\n--- error ---\n{error}"
+                # Show output if present
+                if output:
+                    description += f"\n--- output ---\n{output}"
+
+            # Extract timing
+            time_data = state.get("time", {})
+            if time_data:
+                start = time_data.get("start")
+                end = time_data.get("end")
+                if start and end:
+                    duration_ms = end - start
+
+        return cls(
+            timestamp=timestamp,
+            dt=dt,
+            event_type=event_type,
+            source=source,
+            description=description,
+            raw=raw,
+            cost=cost,
+            duration_ms=duration_ms,
+        )
+
+
+@dataclass
+class AgentState:
+    """
+    State tracking for a single agent/source.
+
+    Attributes
+    ----------
+    name : str
+        Agent/source name.
+    is_running : bool
+        Whether the agent is still running.
+    events : list[LogEvent]
+        List of events for this agent.
+    total_cost : float
+        Accumulated cost.
+    start_time : datetime | None
+        Start time of first event.
+    end_time : datetime | None
+        End time of last event.
+    """
+
+    name: str
+    is_running: bool = True
+    events: list[LogEvent] = field(default_factory=list)
+    total_cost: float = 0.0
+    start_time: datetime | None = None
+    end_time: datetime | None = None
+
+    def add_event(self, event: LogEvent) -> bool:
+        """
+        Add event and update computed state.
+
+        Deduplicates events based on timestamp to prevent duplicates
+        from watchdog firing multiple events.
+
+        Parameters
+        ----------
+        event : LogEvent
+            Event to add.
+
+        Returns
+        -------
+        bool
+            True if event was added, False if it was a duplicate.
+        """
+        # Deduplicate based on timestamp (events with same timestamp are duplicates)
+        # Skip deduplication for timestamp=0 events (raw_text, additional_output)
+        if event.timestamp > 0 and any(e.timestamp == event.timestamp for e in self.events):
+            return False
+
+        self.events.append(event)
+        self.total_cost += event.cost
+
+        # Only update timing from events with real timestamps (not raw text / additional_output)
+        if event.timestamp > 0:
+            if self.start_time is None or event.dt < self.start_time:
+                self.start_time = event.dt
+            if self.end_time is None or event.dt > self.end_time:
+                self.end_time = event.dt
+
+        return True
+
+
+@dataclass
+class SessionState:
+    """
+    Overall session state.
+
+    Attributes
+    ----------
+    work_dir : Path
+        Path to work directory.
+    agents : dict[str, AgentState]
+        Agent states keyed by name.
+    global_start_ts : int | None
+        Earliest timestamp across all agents.
+    is_job_running : bool
+        Whether the job is still running.
+    """
+
+    work_dir: Path
+    agents: dict[str, AgentState] = field(default_factory=dict)
+    global_start_ts: int | None = None
+    is_job_running: bool = True
+
+    @property
+    def total_cost(self) -> float:
+        """Sum of all agent costs."""
+        return sum(a.total_cost for a in self.agents.values())
+
+    @property
+    def duration_seconds(self) -> float:
+        """
+        Duration from first to last timestamp in logs.
+
+        NEVER uses datetime.now() - duration is purely derived from
+        log timestamps so the view is identical whether viewed live
+        or a year later.
+        """
+        if self.global_start_ts is None:
+            return 0.0
+
+        start_dt = datetime.fromtimestamp(self.global_start_ts / 1000)
+
+        # Find latest end time from all agents (from log timestamps only)
+        end_times = [
+            a.end_time for a in self.agents.values() if a.end_time is not None
+        ]
+        if end_times:
+            end_dt = max(end_times)
+        else:
+            # No events yet - duration is 0
+            return 0.0
+
+        return (end_dt - start_dt).total_seconds()
+
+    def get_or_create_agent(self, name: str) -> AgentState:
+        """
+        Get existing agent state or create new one.
+
+        Parameters
+        ----------
+        name : str
+            Agent name.
+
+        Returns
+        -------
+        AgentState
+            Agent state.
+        """
+        if name not in self.agents:
+            self.agents[name] = AgentState(name=name)
+        return self.agents[name]

dlab/tui/widgets/__init__.py

@@ -0,0 +1,18 @@
+"""
+TUI widgets for dlab connect.
+"""
+
+from dlab.tui.widgets.agent_list import AgentSelector
+from dlab.tui.widgets.log_view import LogView
+from dlab.tui.widgets.status_bar import StatusBar
+from dlab.tui.widgets.artifacts_pane import ArtifactList, FileViewer
+from dlab.tui.widgets.search_popup import SearchPopup
+
+__all__ = [
+    "AgentSelector",
+    "LogView",
+    "StatusBar",
+    "ArtifactList",
+    "FileViewer",
+    "SearchPopup",
+]