aline-ai 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

realign/dashboard/screens/create_agent.py

@@ -60,6 +60,23 @@ def _save_claude_permission_mode(mode: str) -> None:
     _save_state("claude_permission_mode", mode)
 
 
+def _load_claude_tracking_mode() -> str:
+    """Load the last used Claude tracking mode from state file."""
+    try:
+        if DASHBOARD_STATE_FILE.exists():
+            with open(DASHBOARD_STATE_FILE, "r", encoding="utf-8") as f:
+                state = json.load(f)
+                return state.get("claude_tracking_mode", "track")
+    except Exception:
+        pass
+    return "track"
+
+
+def _save_claude_tracking_mode(mode: str) -> None:
+    """Save the Claude tracking mode to state file."""
+    _save_state("claude_tracking_mode", mode)
+
+
 def _save_state(key: str, value: str) -> None:
     """Save a key-value pair to the state file."""
     try:
@@ -75,10 +92,10 @@ def _save_state(key: str, value: str) -> None:
         pass
 
 
-class CreateAgentScreen(ModalScreen[Optional[tuple[str, str, bool]]]):
+class CreateAgentScreen(ModalScreen[Optional[tuple[str, str, bool, bool]]]):
     """Modal to create a new agent terminal.
 
-    Returns a tuple of (agent_type, workspace_path, skip_permissions) on success, None on cancel.
+    Returns a tuple of (agent_type, workspace_path, skip_permissions, no_track) on success, None on cancel.
     """
 
     BINDINGS = [
@@ -175,6 +192,7 @@ class CreateAgentScreen(ModalScreen[Optional[tuple[str, str, bool]]]):
         super().__init__()
         self._workspace_path = _load_last_workspace()
         self._permission_mode = _load_claude_permission_mode()
+        self._tracking_mode = _load_claude_tracking_mode()
 
     def compose(self) -> ComposeResult:
         with Container(id="create-agent-root"):
@@ -199,6 +217,11 @@ class CreateAgentScreen(ModalScreen[Optional[tuple[str, str, bool]]]):
                     yield RadioButton("Normal", id="perm-normal", value=True)
                     yield RadioButton("Skip (--dangerously-skip-permissions)", id="perm-skip")
 
+                yield Label("Tracking", classes="section-label")
+                with RadioSet(id="tracking-mode"):
+                    yield RadioButton("Track", id="track-track", value=True)
+                    yield RadioButton("No Track (skip LLM summaries)", id="track-notrack")
+
             with Horizontal(id="buttons"):
                 yield Button("Cancel", id="cancel")
                 yield Button("Create", id="create", variant="primary")
@@ -209,6 +232,11 @@ class CreateAgentScreen(ModalScreen[Optional[tuple[str, str, bool]]]):
             self.query_one("#perm-skip", RadioButton).value = True
         else:
             self.query_one("#perm-normal", RadioButton).value = True
+        # Set the saved tracking mode
+        if self._tracking_mode == "notrack":
+            self.query_one("#track-notrack", RadioButton).value = True
+        else:
+            self.query_one("#track-track", RadioButton).value = True
         self.query_one("#create", Button).focus()
 
     def action_close(self) -> None:
@@ -292,8 +320,9 @@ class CreateAgentScreen(ModalScreen[Optional[tuple[str, str, bool]]]):
             }
             agent_type = agent_type_map.get(pressed_button.id or "", "claude")
 
-            # Get permission mode (only relevant for Claude)
+            # Get permission mode and tracking mode (only relevant for Claude)
             skip_permissions = False
+            no_track = False
             if agent_type == "claude":
                 perm_radio_set = self.query_one("#permission-mode", RadioSet)
                 perm_pressed = perm_radio_set.pressed_button
@@ -302,8 +331,16 @@ class CreateAgentScreen(ModalScreen[Optional[tuple[str, str, bool]]]):
                 permission_mode = "skip" if skip_permissions else "normal"
                 _save_claude_permission_mode(permission_mode)
 
+                # Get tracking mode
+                track_radio_set = self.query_one("#tracking-mode", RadioSet)
+                track_pressed = track_radio_set.pressed_button
+                no_track = track_pressed is not None and track_pressed.id == "track-notrack"
+                # Save the tracking mode for next time
+                tracking_mode = "notrack" if no_track else "track"
+                _save_claude_tracking_mode(tracking_mode)
+
             # Save the workspace path for next time
             _save_last_workspace(self._workspace_path)
 
             # Return the result
-            self.dismiss((agent_type, self._workspace_path, skip_permissions))
+            self.dismiss((agent_type, self._workspace_path, skip_permissions, no_track))

realign/dashboard/terminal_backend.py

@@ -0,0 +1,110 @@
+"""Terminal backend interface for native terminal support.
+
+This module defines the protocol for terminal backends (iTerm2, Kitty)
+that allow the Aline Dashboard to control native terminal windows
+instead of using tmux for rendering.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Protocol, runtime_checkable
+
+
+@dataclass
+class TerminalInfo:
+    """Information about a terminal tab/window managed by a backend."""
+
+    terminal_id: str  # Aline internal ID (UUID)
+    session_id: str  # Backend-specific session ID (iTerm2 session_id or Kitty window_id)
+    name: str  # Display name
+    active: bool = False  # Whether this terminal is currently focused
+    claude_session_id: str | None = None  # Claude Code session ID if applicable
+    context_id: str | None = None  # Aline context ID
+    provider: str | None = None  # Terminal provider (claude, codex, etc.)
+    attention: str | None = None  # Attention state (permission_request, stop, etc.)
+    created_at: float | None = None  # Unix timestamp when terminal was created
+    metadata: dict[str, str] = field(default_factory=dict)  # Additional metadata
+
+
+@runtime_checkable
+class TerminalBackend(Protocol):
+    """Protocol for terminal backends.
+
+    Implementations must provide async methods to:
+    - Create new terminal tabs
+    - Focus/switch to existing tabs
+    - Close tabs
+    - List all managed tabs
+    """
+
+    async def create_tab(
+        self,
+        command: str,
+        terminal_id: str,
+        *,
+        name: str | None = None,
+        env: dict[str, str] | None = None,
+        cwd: str | None = None,
+    ) -> str | None:
+        """Create a new terminal tab.
+
+        Args:
+            command: The command to run in the new tab
+            terminal_id: Aline internal terminal ID
+            name: Optional display name for the tab
+            env: Optional environment variables to set
+            cwd: Optional working directory
+
+        Returns:
+            Backend-specific session ID, or None if creation failed
+        """
+        ...
+
+    async def focus_tab(self, session_id: str, *, steal_focus: bool = False) -> bool:
+        """Switch to/focus a terminal tab.
+
+        Args:
+            session_id: Backend-specific session ID
+            steal_focus: If True, also bring the terminal window to front.
+                         If False, switch tab but keep focus on Dashboard.
+
+        Returns:
+            True if successful, False otherwise
+        """
+        ...
+
+    async def close_tab(self, session_id: str) -> bool:
+        """Close a terminal tab.
+
+        Args:
+            session_id: Backend-specific session ID
+
+        Returns:
+            True if successful, False otherwise
+        """
+        ...
+
+    async def list_tabs(self) -> list[TerminalInfo]:
+        """List all terminal tabs managed by this backend.
+
+        Returns:
+            List of TerminalInfo objects for each managed tab
+        """
+        ...
+
+    async def is_available(self) -> bool:
+        """Check if this backend is available and usable.
+
+        Returns:
+            True if the backend can be used, False otherwise
+        """
+        ...
+
+    def get_backend_name(self) -> str:
+        """Get the human-readable name of this backend.
+
+        Returns:
+            Backend name (e.g., "iTerm2", "Kitty")
+        """
+        ...

realign/dashboard/tmux_manager.py

@@ -45,6 +45,7 @@ OPT_TRANSCRIPT_PATH = "@aline_transcript_path"
 OPT_CONTEXT_ID = "@aline_context_id"
 OPT_ATTENTION = "@aline_attention"
 OPT_CREATED_AT = "@aline_created_at"
+OPT_NO_TRACK = "@aline_no_track"
 
 
 @dataclass(frozen=True)
@@ -60,6 +61,7 @@ class InnerWindow:
     context_id: str | None = None
     attention: str | None = None  # "permission_request", "stop", or None
     created_at: float | None = None  # Unix timestamp when window was created
+    no_track: bool = False  # Whether tracking is disabled for this terminal
 
 
 def tmux_available() -> bool:
@@ -604,6 +606,8 @@ def list_inner_windows() -> list[InnerWindow]:
                 + OPT_ATTENTION
                 + "}\t#{"
                 + OPT_CREATED_AT
+                + "}\t#{"
+                + OPT_NO_TRACK
                 + "}",
             ],
             capture=True,
@@ -632,6 +636,8 @@ def list_inner_windows() -> list[InnerWindow]:
                 created_at = float(created_at_str)
             except ValueError:
                 pass
+        no_track_str = parts[11] if len(parts) > 11 and parts[11] else None
+        no_track = no_track_str == "1"
 
         if terminal_id:
             persisted = state.get(terminal_id) or {}
@@ -663,6 +669,7 @@ def list_inner_windows() -> list[InnerWindow]:
                 context_id=context_id,
                 attention=attention,
                 created_at=created_at,
+                no_track=no_track,
             )
         )
     # Sort by creation time (newest first). Windows without created_at go to the bottom.
@@ -758,6 +765,16 @@ def select_inner_window(window_id: str) -> bool:
     return _run_inner_tmux(["select-window", "-t", window_id]).returncode == 0
 
 
+def focus_right_pane() -> bool:
+    """Focus the right pane (terminal area) in the outer tmux layout."""
+    return (
+        _run_outer_tmux(
+            ["select-pane", "-t", f"{OUTER_SESSION}:{OUTER_WINDOW}.1"]
+        ).returncode
+        == 0
+    )
+
+
 def clear_attention(window_id: str) -> bool:
     """Clear the attention state for a window (e.g., after user acknowledges permission request)."""
     if not ensure_inner_session():