aline-ai 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

realign/dashboard/widgets/terminal_panel.py

@@ -11,7 +11,6 @@ import asyncio
 import os
 import re
 import shlex
-import subprocess
 from pathlib import Path
 from typing import Callable
 
@@ -61,8 +60,7 @@ class _SignalFileWatcher:
         try:
             if PERMISSION_SIGNAL_DIR.exists():
                 self._seen_files = {
-                    f.name for f in PERMISSION_SIGNAL_DIR.iterdir()
-                    if f.suffix == ".signal"
+                    f.name for f in PERMISSION_SIGNAL_DIR.iterdir() if f.suffix == ".signal"
                 }
         except Exception:
             self._seen_files = set()
@@ -89,8 +87,7 @@ class _SignalFileWatcher:
 
                     # Check for new signal files
                     current_files = {
-                        f.name for f in PERMISSION_SIGNAL_DIR.iterdir()
-                        if f.suffix == ".signal"
+                        f.name for f in PERMISSION_SIGNAL_DIR.iterdir() if f.suffix == ".signal"
                     }
                     new_files = current_files - self._seen_files
 
@@ -115,7 +112,7 @@ class _SignalFileWatcher:
             files = sorted(
                 PERMISSION_SIGNAL_DIR.glob("*.signal"),
                 key=lambda f: f.stat().st_mtime,
-                reverse=True
+                reverse=True,
             )
             # Keep only the 10 most recent
             for f in files[10:]:
@@ -132,6 +129,7 @@ class TerminalPanel(Container, can_focus=True):
 
     class PermissionRequestDetected(Message):
         """Posted when a new permission request signal file is detected."""
+
         pass
 
     DEFAULT_CSS = """
@@ -295,14 +293,17 @@ class TerminalPanel(Container, can_focus=True):
     def compose(self) -> ComposeResult:
         controls_enabled = self.supported()
         with Horizontal(classes="summary"):
-            yield Button("＋ Claude", id="new-cc", variant="primary", disabled=not controls_enabled)
-            yield Button("＋ Codex", id="new-codex", variant="primary", disabled=not controls_enabled)
-            yield Button("＋ zsh", id="new-zsh", variant="primary", disabled=not controls_enabled)
-            yield Button("↻", id="refresh")
-            yield Static("", id="status", classes="status")
+            yield Button(
+                "＋ Create",
+                id="new-agent",
+                variant="primary",
+                disabled=not controls_enabled,
+            )
         with Vertical(id="terminals", classes="list"):
             if controls_enabled:
-                yield Static("No terminals yet. Click 'New cc' / 'New codex' to open the right pane.")
+                yield Static(
+                    "No terminals yet. Click 'Create' to open a new agent terminal."
+                )
             else:
                 yield Static(self._support_message())
 
@@ -356,21 +357,15 @@ class TerminalPanel(Container, can_focus=True):
         async with self._refresh_lock:
             try:
                 supported = self.supported()
-            except Exception as e:
-                self._set_status(f"Terminal support check failed: {e}")
+            except Exception:
                 return
 
             if not supported:
-                try:
-                    self._set_status(self._support_message())
-                except Exception:
-                    self._set_status("Terminal not supported")
                 return
 
             try:
                 windows = tmux_manager.list_inner_windows()
-            except Exception as e:
-                self._set_status(f"Failed to query tmux windows: {e}")
+            except Exception:
                 return
             active_window_id = next((w.window_id for w in windows if w.active), None)
             if self._expanded_window_id and self._expanded_window_id != active_window_id:
@@ -385,10 +380,16 @@ class TerminalPanel(Container, can_focus=True):
             for w in windows:
                 if not self._is_claude_window(w) or not w.context_id:
                     continue
-                session_ids, session_count, event_count = self._get_loaded_context_info(w.context_id)
+                session_ids, session_count, event_count = self._get_loaded_context_info(
+                    w.context_id
+                )
                 if not session_ids and session_count == 0 and event_count == 0:
                     continue
-                context_info_by_context_id[w.context_id] = (session_ids, session_count, event_count)
+                context_info_by_context_id[w.context_id] = (
+                    session_ids,
+                    session_count,
+                    event_count,
+                )
                 all_context_session_ids.update(session_ids)
 
             if all_context_session_ids:
@@ -396,10 +397,8 @@ class TerminalPanel(Container, can_focus=True):
 
             try:
                 await self._render_terminals(windows, titles, context_info_by_context_id)
-            except Exception as e:
-                self._set_status(f"Failed to render terminal list: {e}")
+            except Exception:
                 return
-            self._set_status(f"{len(windows)} terminals")
 
     def _fetch_claude_session_titles(self, session_ids: list[str]) -> dict[str, str]:
         if not session_ids:
@@ -464,12 +463,6 @@ class TerminalPanel(Container, can_focus=True):
         except Exception:
             return ([], 0, 0)
 
-    def _set_status(self, text: str) -> None:
-        try:
-            self.query_one("#status", Static).update(text)
-        except Exception:
-            pass
-
     async def _render_terminals(
         self,
         windows: list[tmux_manager.InnerWindow],
@@ -481,7 +474,7 @@ class TerminalPanel(Container, can_focus=True):
 
         if not windows:
             await container.mount(
-                Static("No terminals yet. Click 'New cc' / 'New codex' to open the right pane.")
+                Static("No terminals yet. Click 'Create' to open a new agent terminal.")
             )
             return
 
@@ -516,9 +509,7 @@ class TerminalPanel(Container, can_focus=True):
             if w.active and can_toggle_ctx:
                 await row.mount(
                     Button(
-                        # Avoid Rich crash when Textual measures with width=0 (can happen during
-                        # initial layout / tab switching).
-                        "⮟" if expanded else "⮞",
+                        "▼" if expanded else "▶",
                         id=f"toggle-{safe}",
                         name=w.window_id,
                         variant="default",
@@ -536,12 +527,7 @@ class TerminalPanel(Container, can_focus=True):
                 )
             )
 
-            if (
-                w.active
-                and self._is_claude_window(w)
-                and w.context_id
-                and expanded
-            ):
+            if w.active and self._is_claude_window(w) and w.context_id and expanded:
                 ctx = VerticalScroll(id=f"ctx-{safe}", classes="context-sessions")
                 await container.mount(ctx)
                 if loaded_ids:
@@ -591,16 +577,17 @@ class TerminalPanel(Container, can_focus=True):
         details.append(header)
         details.append("\n")
 
-        # Include window_name to distinguish terminals with same session_id
-        window_name = w.window_name or ""
-        detail_line = f"[{window_name}]" if window_name else "claude"
+        # Build detail line with Claude label
+        detail_line = "[Claude]"
         if w.session_id:
             detail_line = f"{detail_line} #{self._short_id(w.session_id)}"
         if w.active:
             loaded_count = raw_sessions + raw_events
             detail_line = f"{detail_line} | loaded context: {loaded_count}"
         else:
-            detail_line = f"{detail_line} · {self._format_context_summary(raw_sessions, raw_events)}"
+            detail_line = (
+                f"{detail_line} · {self._format_context_summary(raw_sessions, raw_events)}"
+            )
         details.append(detail_line, style="dim not bold")
         return details
 
@@ -621,156 +608,149 @@ class TerminalPanel(Container, can_focus=True):
             return f"w-{safe}"
         return safe
 
-    async def _select_workspace(self, prompt: str = "Select workspace") -> str | None:
-        """Open macOS folder picker and return selected path, or None if cancelled."""
-        try:
-            default_path = os.getcwd()
-        except Exception:
-            # Can happen if the original working directory was deleted/moved.
-            default_path = str(Path.home())
-        # Use osascript to invoke macOS native folder picker
-        default_path_escaped = default_path.replace('"', '\\"')
-        prompt_escaped = prompt.replace('"', '\\"')
-        script = f'''
-            set defaultFolder to POSIX file "{default_path_escaped}" as alias
-            try
-                set selectedFolder to choose folder with prompt "{prompt_escaped}" default location defaultFolder
-                return POSIX path of selectedFolder
-            on error
-                return ""
-            end try
-        '''
-        try:
-            proc = await asyncio.get_event_loop().run_in_executor(
-                None,
-                lambda: subprocess.run(
-                    ["osascript", "-e", script],
-                    capture_output=True,
-                    text=True,
-                    timeout=120,
-                ),
-            )
-            result = (proc.stdout or "").strip()
-            if result and os.path.isdir(result):
-                return result
-            return None
-        except Exception:
-            return None
-
     @staticmethod
     def _command_in_directory(command: str, directory: str) -> str:
         """Wrap a command to run in a specific directory."""
         return f"cd {shlex.quote(directory)} && {command}"
 
-    async def on_button_pressed(self, event: Button.Pressed) -> None:
-        button_id = event.button.id or ""
-
-        if button_id == "refresh":
-            await self.refresh_data()
+    def _on_create_agent_result(self, result: tuple[str, str] | None) -> None:
+        """Handle the result from CreateAgentScreen modal."""
+        if result is None:
             return
 
-        if not self.supported():
-            self.app.notify(
-                self._support_message(),
-                title="Terminal",
-                severity="warning",
-            )
-            return
-
-        if button_id == "new-cc":
-            workspace = await self._select_workspace("Select workspace for Claude")
-            if not workspace:
-                return
+        agent_type, workspace = result
+        self.run_worker(
+            self._create_agent(agent_type, workspace),
+            group="terminal-panel-create",
+            exclusive=True,
+        )
 
-            terminal_id = tmux_manager.new_terminal_id()
-            context_id = tmux_manager.new_context_id("cc")
-            env = {
-                tmux_manager.ENV_TERMINAL_ID: terminal_id,
-                tmux_manager.ENV_TERMINAL_PROVIDER: "claude",
-                tmux_manager.ENV_INNER_SOCKET: tmux_manager.INNER_SOCKET,
-                tmux_manager.ENV_INNER_SESSION: tmux_manager.INNER_SESSION,
-                tmux_manager.ENV_CONTEXT_ID: context_id,
-            }
+    async def _create_agent(self, agent_type: str, workspace: str) -> None:
+        """Create a new agent terminal based on the selected type and workspace."""
+        if agent_type == "claude":
+            await self._create_claude_terminal(workspace)
+        elif agent_type == "codex":
+            await self._create_codex_terminal(workspace)
+        elif agent_type == "opencode":
+            await self._create_opencode_terminal(workspace)
+        elif agent_type == "zsh":
+            await self._create_zsh_terminal(workspace)
+        await self.refresh_data()
+
+    async def _create_claude_terminal(self, workspace: str) -> None:
+        """Create a new Claude terminal."""
+        terminal_id = tmux_manager.new_terminal_id()
+        context_id = tmux_manager.new_context_id("cc")
+        env = {
+            tmux_manager.ENV_TERMINAL_ID: terminal_id,
+            tmux_manager.ENV_TERMINAL_PROVIDER: "claude",
+            tmux_manager.ENV_INNER_SOCKET: tmux_manager.INNER_SOCKET,
+            tmux_manager.ENV_INNER_SESSION: tmux_manager.INNER_SESSION,
+            tmux_manager.ENV_CONTEXT_ID: context_id,
+        }
 
-            try:
-                from pathlib import Path
+        try:
+            from ...claude_hooks.stop_hook_installer import (
+                ensure_stop_hook_installed,
+                get_settings_path as get_stop_settings_path,
+                install_stop_hook,
+            )
+            from ...claude_hooks.user_prompt_submit_hook_installer import (
+                ensure_user_prompt_submit_hook_installed,
+                get_settings_path as get_submit_settings_path,
+                install_user_prompt_submit_hook,
+            )
+            from ...claude_hooks.permission_request_hook_installer import (
+                ensure_permission_request_hook_installed,
+                get_settings_path as get_permission_settings_path,
+                install_permission_request_hook,
+            )
 
-                from ...claude_hooks.stop_hook_installer import (
-                    ensure_stop_hook_installed,
-                    get_settings_path as get_stop_settings_path,
-                    install_stop_hook,
-                )
-                from ...claude_hooks.user_prompt_submit_hook_installer import (
-                    ensure_user_prompt_submit_hook_installed,
-                    get_settings_path as get_submit_settings_path,
-                    install_user_prompt_submit_hook,
-                )
-                from ...claude_hooks.permission_request_hook_installer import (
-                    ensure_permission_request_hook_installed,
-                    get_settings_path as get_permission_settings_path,
-                    install_permission_request_hook,
-                )
+            ok_global_stop = ensure_stop_hook_installed(quiet=True)
+            ok_global_submit = ensure_user_prompt_submit_hook_installed(quiet=True)
+            ok_global_permission = ensure_permission_request_hook_installed(quiet=True)
 
-                ok_global_stop = ensure_stop_hook_installed(quiet=True)
-                ok_global_submit = ensure_user_prompt_submit_hook_installed(quiet=True)
-                ok_global_permission = ensure_permission_request_hook_installed(quiet=True)
+            project_root = Path(workspace)
+            ok_project_stop = install_stop_hook(
+                get_stop_settings_path(project_root), quiet=True
+            )
+            ok_project_submit = install_user_prompt_submit_hook(
+                get_submit_settings_path(project_root), quiet=True
+            )
+            ok_project_permission = install_permission_request_hook(
+                get_permission_settings_path(project_root), quiet=True
+            )
 
-                project_root = Path(workspace)
-                ok_project_stop = install_stop_hook(get_stop_settings_path(project_root), quiet=True)
-                ok_project_submit = install_user_prompt_submit_hook(
-                    get_submit_settings_path(project_root), quiet=True
-                )
-                ok_project_permission = install_permission_request_hook(
-                    get_permission_settings_path(project_root), quiet=True
+            all_hooks_ok = (
+                ok_global_stop
+                and ok_global_submit
+                and ok_global_permission
+                and ok_project_stop
+                and ok_project_submit
+                and ok_project_permission
+            )
+            if not all_hooks_ok:
+                self.app.notify(
+                    "Claude hooks not fully installed; session id/title may not update",
+                    title="Terminal",
+                    severity="warning",
                 )
+        except Exception:
+            pass
 
-                all_hooks_ok = (
-                    ok_global_stop and ok_global_submit and ok_global_permission
-                    and ok_project_stop and ok_project_submit and ok_project_permission
-                )
-                if not all_hooks_ok:
-                    self.app.notify(
-                        "Claude hooks not fully installed; session id/title may not update",
-                        title="Terminal",
-                        severity="warning",
-                    )
-            except Exception:
-                pass
+        command = self._command_in_directory(
+            tmux_manager.zsh_run_and_keep_open("claude"), workspace
+        )
+        created = tmux_manager.create_inner_window(
+            "cc",
+            tmux_manager.shell_command_with_env(command, env),
+            terminal_id=terminal_id,
+            provider="claude",
+            context_id=context_id,
+        )
+        if not created:
+            self.app.notify("Failed to open Claude terminal", title="Terminal", severity="error")
 
-            command = self._command_in_directory(
-                tmux_manager.zsh_run_and_keep_open("claude"), workspace
-            )
-            created = tmux_manager.create_inner_window(
-                "cc",
-                tmux_manager.shell_command_with_env(command, env),
-                terminal_id=terminal_id,
-                provider="claude",
-                context_id=context_id,
-            )
-            if not created:
-                self.app.notify("Failed to open cc terminal", title="Terminal", severity="error")
-            await self.refresh_data()
-            return
+    async def _create_codex_terminal(self, workspace: str) -> None:
+        """Create a new Codex terminal."""
+        command = self._command_in_directory(
+            tmux_manager.zsh_run_and_keep_open("codex"), workspace
+        )
+        created = tmux_manager.create_inner_window("codex", command)
+        if not created:
+            self.app.notify("Failed to open Codex terminal", title="Terminal", severity="error")
+
+    async def _create_opencode_terminal(self, workspace: str) -> None:
+        """Create a new Opencode terminal."""
+        command = self._command_in_directory(
+            tmux_manager.zsh_run_and_keep_open("opencode"), workspace
+        )
+        created = tmux_manager.create_inner_window("opencode", command)
+        if not created:
+            self.app.notify("Failed to open Opencode terminal", title="Terminal", severity="error")
 
-        if button_id == "new-codex":
-            workspace = await self._select_workspace("Select workspace for Codex")
-            if not workspace:
-                return
+    async def _create_zsh_terminal(self, workspace: str) -> None:
+        """Create a new zsh terminal."""
+        command = self._command_in_directory("zsh", workspace)
+        created = tmux_manager.create_inner_window("zsh", command)
+        if not created:
+            self.app.notify("Failed to open zsh terminal", title="Terminal", severity="error")
 
-            command = self._command_in_directory(
-                tmux_manager.zsh_run_and_keep_open("codex"), workspace
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        button_id = event.button.id or ""
+
+        if not self.supported():
+            self.app.notify(
+                self._support_message(),
+                title="Terminal",
+                severity="warning",
             )
-            created = tmux_manager.create_inner_window("codex", command)
-            if not created:
-                self.app.notify("Failed to open codex terminal", title="Terminal", severity="error")
-            await self.refresh_data()
             return
 
-        if button_id == "new-zsh":
-            created = tmux_manager.create_inner_window("zsh", "zsh")
-            if not created:
-                self.app.notify("Failed to open zsh terminal", title="Terminal", severity="error")
-            await self.refresh_data()
+        if button_id == "new-agent":
+            from ..screens import CreateAgentScreen
+
+            self.app.push_screen(CreateAgentScreen(), self._on_create_agent_result)
             return
 
         if button_id.startswith("switch-"):

realign/dashboard/widgets/watcher_panel.py

@@ -389,7 +389,9 @@ class WatcherPanel(Container, can_focus=True):
         except Exception:
             return []
 
-    def _collect_recent_sessions_page(self, *, page: int, rows_per_page: int) -> tuple[list[dict], int]:
+    def _collect_recent_sessions_page(
+        self, *, page: int, rows_per_page: int
+    ) -> tuple[list[dict], int]:
         """Collect one page of recent sessions from the database."""
         try:
             from ...db import get_database
@@ -477,7 +479,9 @@ class WatcherPanel(Container, can_focus=True):
                 if exists:
                     paths_lines.append(f"  [green]●[/green] {name}: {path}")
                 else:
-                    paths_lines.append(f"  [yellow]○[/yellow] {name}: {path} [dim](not found)[/dim]")
+                    paths_lines.append(
+                        f"  [yellow]○[/yellow] {name}: {path} [dim](not found)[/dim]"
+                    )
             else:
                 paths_lines.append(f"  [dim]○ {name}: {path} (disabled)[/dim]")
         paths_widget.update("\n".join(paths_lines))

realign/dashboard/widgets/worker_panel.py

@@ -483,7 +483,16 @@ class WorkerPanel(Container, can_focus=True):
             ("Failed", failed, "red"),
         ]:
             bar_width = int((count / total) * max_width) if total > 0 else 0
-            bar = "[" + color + "]" + ("█" * bar_width) + "[/" + color + "]" + ("░" * (max_width - bar_width))
+            bar = (
+                "["
+                + color
+                + "]"
+                + ("█" * bar_width)
+                + "[/"
+                + color
+                + "]"
+                + ("░" * (max_width - bar_width))
+            )
             lines.append(f"  {label:<12} {bar}  {count}")
 
         return "\n".join(lines)

realign/db/__init__.py

@@ -20,7 +20,7 @@ def get_database(
       blocking CLI commands under worker/watcher write load.
     """
     global _DB_INSTANCE
-    
+
     # Resolution order:
     # 1) Env override (tests/ops): REALIGN_SQLITE_DB_PATH or REALIGN_DB_PATH (legacy)
     # 2) Config: ~/.aline/config.yaml (sqlite_db_path)

realign/db/base.py

@@ -121,9 +121,7 @@ class DatabaseInterface(ABC):
         pass
 
     @abstractmethod
-    def get_or_create_project(
-        self, path: Path, name: Optional[str] = None
-    ) -> ProjectRecord:
+    def get_or_create_project(self, path: Path, name: Optional[str] = None) -> ProjectRecord:
         """Get existing project or create new one."""
         pass
 
@@ -141,9 +139,7 @@ class DatabaseInterface(ABC):
         pass
 
     @abstractmethod
-    def update_session_activity(
-        self, session_id: str, last_activity_at: datetime
-    ) -> None:
+    def update_session_activity(self, session_id: str, last_activity_at: datetime) -> None:
         """Update last activity timestamp for a session."""
         pass
 
@@ -212,16 +208,12 @@ class DatabaseInterface(ABC):
         pass
 
     @abstractmethod
-    def get_turn_by_hash(
-        self, session_id: str, content_hash: str
-    ) -> Optional[TurnRecord]:
+    def get_turn_by_hash(self, session_id: str, content_hash: str) -> Optional[TurnRecord]:
         """Check if a turn with this content hash already exists in the session."""
         pass
 
     @abstractmethod
-    def get_turn_by_number(
-        self, session_id: str, turn_number: int
-    ) -> Optional[TurnRecord]:
+    def get_turn_by_number(self, session_id: str, turn_number: int) -> Optional[TurnRecord]:
         """Get a turn by session_id and turn_number."""
         pass
 
@@ -379,9 +371,7 @@ class DatabaseInterface(ABC):
         pass
 
     @abstractmethod
-    def try_acquire_lock(
-        self, lock_key: str, *, owner: str, ttl_seconds: float
-    ) -> bool:
+    def try_acquire_lock(self, lock_key: str, *, owner: str, ttl_seconds: float) -> bool:
         """Try to acquire a cross-process lease lock."""
         pass
 

realign/db/locks.py

@@ -65,4 +65,3 @@ def lease_lock(
                 db.release_lock(lock_key, owner=lock_owner)
             except Exception:
                 pass
-