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

realign/commands/worker.py

@@ -87,7 +87,11 @@ def worker_status_command(verbose: bool = False, *, json_output: bool = False) -
         # Show job counts if DB available
         try:
             dbi = get_database()
-            db_path = Path(str(getattr(dbi, "db_path", ""))).expanduser() if isinstance(dbi, SQLiteDatabase) else None
+            db_path = (
+                Path(str(getattr(dbi, "db_path", ""))).expanduser()
+                if isinstance(dbi, SQLiteDatabase)
+                else None
+            )
             if isinstance(dbi, SQLiteDatabase):
                 counts = dbi.get_job_counts()
                 turn_jobs = dbi.list_jobs(limit=30, kinds=["turn_summary"])
@@ -116,6 +120,7 @@ def worker_status_command(verbose: bool = False, *, json_output: bool = False) -
             job_kinds = {}
 
         if json_output:
+
             def _session_id_from_job(job: dict) -> str:
                 payload = job.get("payload") or {}
                 session_id = str(payload.get("session_id") or "").strip()
@@ -133,7 +138,11 @@ def worker_status_command(verbose: bool = False, *, json_output: bool = False) -
             session_type_by_id: dict[str, str] = {}
             if isinstance(dbi, SQLiteDatabase):
                 session_ids = sorted(
-                    {sid for sid in (_session_id_from_job(j) for j in (turn_jobs + session_jobs)) if sid}
+                    {
+                        sid
+                        for sid in (_session_id_from_job(j) for j in (turn_jobs + session_jobs))
+                        if sid
+                    }
                 )
                 if session_ids:
                     for s in dbi.get_sessions_by_ids(session_ids):
@@ -196,7 +205,12 @@ def worker_status_command(verbose: bool = False, *, json_output: bool = False) -
                 }
 
             data = {
-                "worker": {"status": status.lower(), "running": is_running, "pid": pid, "mode": mode},
+                "worker": {
+                    "status": status.lower(),
+                    "running": is_running,
+                    "pid": pid,
+                    "mode": mode,
+                },
                 "db_path": str(db_path) if db_path else None,
                 "job_counts": counts,
                 "job_kinds": job_kinds,
@@ -206,7 +220,9 @@ def worker_status_command(verbose: bool = False, *, json_output: bool = False) -
             print(json.dumps(data, ensure_ascii=True))
             return 0
 
-        console.print(f"[bold]Worker:[/bold] {status}" + (f" (PID: {pid}, mode: {mode})" if pid else ""))
+        console.print(
+            f"[bold]Worker:[/bold] {status}" + (f" (PID: {pid}, mode: {mode})" if pid else "")
+        )
         if db_path:
             console.print(f"[dim]DB:[/dim] {db_path}")
         if counts:
@@ -225,6 +241,7 @@ def worker_status_command(verbose: bool = False, *, json_output: bool = False) -
                 console.print(f"[dim]Job kinds:[/dim] {pairs}")
 
         try:
+
             def fmt_status(s: str) -> tuple[str, str]:
                 s = (s or "").lower()
                 if s == "processing":
@@ -254,7 +271,11 @@ def worker_status_command(verbose: bool = False, *, json_output: bool = False) -
             session_type_by_id: dict[str, str] = {}
             if isinstance(dbi, SQLiteDatabase):
                 session_ids = sorted(
-                    {sid for sid in (_session_id_from_job(j) for j in (turn_jobs + session_jobs)) if sid}
+                    {
+                        sid
+                        for sid in (_session_id_from_job(j) for j in (turn_jobs + session_jobs))
+                        if sid
+                    }
                 )
                 if session_ids:
                     for s in dbi.get_sessions_by_ids(session_ids):
@@ -501,7 +522,9 @@ def worker_stop_command() -> int:
             pid, mode = all_processes[0]
             console.print(f"[cyan]Stopping worker (PID: {pid}, mode: {mode})...[/cyan]")
         else:
-            console.print(f"[cyan]Found {len(all_processes)} worker processes, stopping all...[/cyan]")
+            console.print(
+                f"[cyan]Found {len(all_processes)} worker processes, stopping all...[/cyan]"
+            )
 
         for pid, _mode in all_processes:
             try:

realign/config.py

@@ -12,36 +12,38 @@ class ReAlignConfig:
     """ReAlign configuration."""
 
     summary_max_chars: int = 500
-    redact_on_match: bool = False    # Default: disable redaction (can be enabled in config)
+    redact_on_match: bool = False  # Default: disable redaction (can be enabled in config)
     hooks_installation: str = "repo"
     sqlite_db_path: str = "~/.aline/db/aline.db"  # Path to SQLite database
     use_LLM: bool = True
-    llm_provider: str = "auto"       # LLM provider: "auto", "claude", or "openai"
+    llm_provider: str = "auto"  # LLM provider: "auto", "claude", or "openai"
     auto_detect_claude: bool = True  # Enable Claude Code session auto-detection
-    auto_detect_codex: bool = True   # Enable Codex session auto-detection
-    auto_detect_gemini: bool = True # Enable Gemini CLI session auto-detection
-    auto_detect_antigravity: bool = False # Enable Antigravity IDE brain artifact monitoring
-    mcp_auto_commit: bool = True     # Enable watcher auto-commit after each user request completes
+    auto_detect_codex: bool = True  # Enable Codex session auto-detection
+    auto_detect_gemini: bool = True  # Enable Gemini CLI session auto-detection
+    auto_detect_antigravity: bool = False  # Enable Antigravity IDE brain artifact monitoring
+    mcp_auto_commit: bool = True  # Enable watcher auto-commit after each user request completes
     enable_temp_turn_titles: bool = True  # Generate temporary turn titles on user prompt submit
-    share_backend_url: str = "https://realign-server.vercel.app"  # Backend URL for interactive share export
+    share_backend_url: str = (
+        "https://realign-server.vercel.app"  # Backend URL for interactive share export
+    )
 
     # User identity (V9)
-    user_name: str = ""                             # User's display name (set during init)
-    user_id: str = ""                               # User's UUID (generated from MAC address)
+    user_name: str = ""  # User's display name (set during init)
+    user_id: str = ""  # User's UUID (generated from MAC address)
 
     # Session catch-up settings
-    max_catchup_sessions: int = 3                   # Max sessions to auto-import on watcher startup
+    max_catchup_sessions: int = 3  # Max sessions to auto-import on watcher startup
 
     # LLM API Keys
-    anthropic_api_key: Optional[str] = None         # Anthropic API key (set in config, not environment)
-    openai_api_key: Optional[str] = None            # OpenAI API key (set in config, not environment)
+    anthropic_api_key: Optional[str] = None  # Anthropic API key (set in config, not environment)
+    openai_api_key: Optional[str] = None  # OpenAI API key (set in config, not environment)
 
     # LLM Model Configuration
     llm_anthropic_model: str = "claude-3-5-haiku-20241022"  # Claude model to use
-    llm_openai_model: str = "gpt-4o-mini"                   # OpenAI model to use
-    llm_openai_use_responses: bool = False                  # Use OpenAI Responses API for reasoning models
-    llm_max_tokens: int = 1000                              # Default max tokens
-    llm_temperature: float = 0.0                            # Default temperature (0.0 = deterministic)
+    llm_openai_model: str = "gpt-4o-mini"  # OpenAI model to use
+    llm_openai_use_responses: bool = False  # Use OpenAI Responses API for reasoning models
+    llm_max_tokens: int = 1000  # Default max tokens
+    llm_temperature: float = 0.0  # Default temperature (0.0 = deterministic)
 
     @classmethod
     def load(cls, config_path: Optional[Path] = None) -> "ReAlignConfig":
@@ -49,12 +51,13 @@ class ReAlignConfig:
         if config_path is None:
             # Default to new location: ~/.aline/config.yaml
             config_path = Path.home() / ".aline" / "config.yaml"
-            
+
             # Check for legacy config and migrate if needed
             legacy_path = Path.home() / ".config" / "realign" / "config.yaml"
             if not config_path.exists() and legacy_path.exists():
                 try:
                     import shutil
+
                     config_path.parent.mkdir(parents=True, exist_ok=True)
                     shutil.move(legacy_path, config_path)
                     # Try to remove empty legacy directory
@@ -172,10 +175,11 @@ def generate_user_id() -> str:
         str: User UUID as a string
     """
     import uuid
+
     try:
         mac = uuid.getnode()
         # Use MAC address with DNS namespace to generate UUID5
-        namespace = uuid.UUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8')  # DNS namespace
+        namespace = uuid.UUID("6ba7b810-9dad-11d1-80b4-00c04fd430c8")  # DNS namespace
         user_uuid = uuid.uuid5(namespace, str(mac))
         return str(user_uuid)
     except Exception:
@@ -194,8 +198,9 @@ def generate_random_username() -> str:
     """
     import random
     import string
-    letters = ''.join(random.choices(string.ascii_lowercase, k=3))
-    digits = ''.join(random.choices(string.digits, k=3))
+
+    letters = "".join(random.choices(string.ascii_lowercase, k=3))
+    digits = "".join(random.choices(string.digits, k=3))
     return letters + digits
 
 

realign/context.py

@@ -245,9 +245,7 @@ def add_context(
         entry = config.contexts[existing_idx]
         # Add new sessions/events (merge, deduplicate)
         if sessions:
-            entry.context_sessions = list(
-                set(entry.context_sessions) | set(sessions)
-            )
+            entry.context_sessions = list(set(entry.context_sessions) | set(sessions))
         if events:
             entry.context_events = list(set(entry.context_events) | set(events))
         entry.loaded_at = datetime.utcnow().isoformat() + "Z"

realign/dashboard/app.py

@@ -54,44 +54,56 @@ class AlineDashboard(App):
     TITLE = "Aline Dashboard"
 
     BINDINGS = [
-        Binding("r", "refresh", "Refresh"),
+        Binding("r", "refresh", "Refresh", show=False),
         Binding("?", "help", "Help"),
-        Binding("tab", "next_tab", "Next Tab", priority=True),
-        Binding("shift+tab", "prev_tab", "Prev Tab", priority=True),
-        Binding("n", "page_next", "Next Page"),
-        Binding("p", "page_prev", "Prev Page"),
-        Binding("s", "switch_view", "Switch View"),
-        Binding("c", "create_event", "Create Event"),
-        Binding("l", "load_context", "Load Context"),
-        Binding("y", "share_import", "Share Import"),
+        Binding("tab", "next_tab", "Next Tab", priority=True, show=False),
+        Binding("shift+tab", "prev_tab", "Prev Tab", priority=True, show=False),
+        Binding("n", "page_next", "Next Page", show=False),
+        Binding("p", "page_prev", "Prev Page", show=False),
+        Binding("s", "switch_view", "Switch View", show=False),
+        Binding("c", "create_event", "Create Event", show=False),
+        Binding("l", "load_context", "Load Context", show=False),
+        Binding("y", "share_import", "Share Import", show=False),
         Binding("ctrl+c", "quit_confirm", "Quit", priority=True),
     ]
 
     _quit_confirm_window_s: float = 1.2
 
+    def __init__(self, dev_mode: bool = False):
+        """Initialize the dashboard.
+
+        Args:
+            dev_mode: If True, shows developer tabs (Watcher, Worker).
+        """
+        super().__init__()
+        self.dev_mode = dev_mode
+
     def compose(self) -> ComposeResult:
         """Compose the dashboard layout."""
         yield AlineHeader()
         tab_ids = self._tab_ids()
-        with TabbedContent(initial=tab_ids[0] if tab_ids else "watcher"):
-            with TabPane("Watcher", id="watcher"):
-                yield WatcherPanel()
-            with TabPane("Worker", id="worker"):
-                yield WorkerPanel()
-            with TabPane("Sessions", id="sessions"):
+        with TabbedContent(initial=tab_ids[0] if tab_ids else "terminal"):
+            with TabPane("Agents", id="terminal"):
+                yield TerminalPanel()
+            if self.dev_mode:
+                with TabPane("Watcher", id="watcher"):
+                    yield WatcherPanel()
+                with TabPane("Worker", id="worker"):
+                    yield WorkerPanel()
+            with TabPane("Contexts", id="sessions"):
                 yield SessionsTable()
-            with TabPane("Events", id="events"):
+            with TabPane("Share", id="events"):
                 yield EventsTable()
             with TabPane("Config", id="config"):
                 yield ConfigPanel()
             with TabPane("Search", id="search"):
                 yield SearchPanel()
-            with TabPane("Terminal", id="terminal"):
-                yield TerminalPanel()
         yield Footer()
 
     def _tab_ids(self) -> list[str]:
-        return ["watcher", "worker", "sessions", "events", "config", "search", "terminal"]
+        if self.dev_mode:
+            return ["terminal", "watcher", "worker", "sessions", "events", "config", "search"]
+        return ["terminal", "sessions", "events", "config", "search"]
 
     def on_mount(self) -> None:
         """Apply theme based on system settings and watch for changes."""
@@ -190,11 +202,9 @@ class AlineDashboard(App):
 
     def action_help(self) -> None:
         """Show help information."""
-        self.notify(
-            "Tab/Shift+Tab: Switch tabs | n/p: Page | Enter/dblclick: Open | space: Toggle select | c: Create event | l: Load ctx | s: Switch view | r: Refresh | Ctrl+C Ctrl+C: Quit",
-            title="Keyboard Shortcuts",
-            timeout=5,
-        )
+        from .screens import HelpScreen
+
+        self.push_screen(HelpScreen())
 
     def action_quit_confirm(self) -> None:
         """Quit only when Ctrl+C is pressed twice quickly."""

realign/dashboard/screens/__init__.py

@@ -3,6 +3,15 @@
 from .session_detail import SessionDetailScreen
 from .event_detail import EventDetailScreen
 from .create_event import CreateEventScreen
+from .create_agent import CreateAgentScreen
 from .share_import import ShareImportScreen
+from .help_screen import HelpScreen
 
-__all__ = ["SessionDetailScreen", "EventDetailScreen", "CreateEventScreen", "ShareImportScreen"]
+__all__ = [
+    "SessionDetailScreen",
+    "EventDetailScreen",
+    "CreateEventScreen",
+    "CreateAgentScreen",
+    "ShareImportScreen",
+    "HelpScreen",
+]

realign/dashboard/screens/create_agent.py

@@ -0,0 +1,244 @@
+"""Create agent modal for the dashboard."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Container, Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Label, RadioButton, RadioSet, Static
+
+
+# State file for storing last workspace path
+DASHBOARD_STATE_FILE = Path.home() / ".aline" / "dashboard_state.json"
+
+
+def _load_last_workspace() -> str:
+    """Load the last used workspace path from state file."""
+    try:
+        if DASHBOARD_STATE_FILE.exists():
+            with open(DASHBOARD_STATE_FILE, "r", encoding="utf-8") as f:
+                state = json.load(f)
+                path = state.get("last_workspace", "")
+                if path and os.path.isdir(path):
+                    return path
+    except Exception:
+        pass
+    # Default to current working directory or home
+    try:
+        return os.getcwd()
+    except Exception:
+        return str(Path.home())
+
+
+def _save_last_workspace(path: str) -> None:
+    """Save the last used workspace path to state file."""
+    try:
+        DASHBOARD_STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        state = {}
+        if DASHBOARD_STATE_FILE.exists():
+            with open(DASHBOARD_STATE_FILE, "r", encoding="utf-8") as f:
+                state = json.load(f)
+        state["last_workspace"] = path
+        with open(DASHBOARD_STATE_FILE, "w", encoding="utf-8") as f:
+            json.dump(state, f, indent=2)
+    except Exception:
+        pass
+
+
+class CreateAgentScreen(ModalScreen[Optional[tuple[str, str]]]):
+    """Modal to create a new agent terminal.
+
+    Returns a tuple of (agent_type, workspace_path) on success, None on cancel.
+    """
+
+    BINDINGS = [
+        Binding("escape", "close", "Close", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    CreateAgentScreen {
+        align: center middle;
+    }
+
+    CreateAgentScreen #create-agent-root {
+        width: 60;
+        height: auto;
+        max-height: 80%;
+        padding: 1 2;
+        background: $background;
+        border: solid $accent;
+    }
+
+    CreateAgentScreen #create-agent-title {
+        height: auto;
+        margin-bottom: 1;
+        text-style: bold;
+    }
+
+    CreateAgentScreen .section-label {
+        height: auto;
+        margin-top: 1;
+        margin-bottom: 0;
+        color: $text-muted;
+    }
+
+    CreateAgentScreen RadioSet {
+        height: auto;
+        margin: 0;
+        padding: 0;
+        border: none;
+        background: transparent;
+    }
+
+    CreateAgentScreen RadioButton {
+        height: auto;
+        padding: 0;
+        margin: 0;
+        background: transparent;
+    }
+
+    CreateAgentScreen #workspace-section {
+        height: auto;
+        margin-top: 1;
+    }
+
+    CreateAgentScreen #workspace-row {
+        height: auto;
+        margin-top: 0;
+    }
+
+    CreateAgentScreen #workspace-path {
+        width: 1fr;
+        height: auto;
+        padding: 0 1;
+        background: $surface;
+        border: solid $primary-lighten-2;
+    }
+
+    CreateAgentScreen #browse-btn {
+        width: auto;
+        min-width: 10;
+        margin-left: 1;
+    }
+
+    CreateAgentScreen #buttons {
+        height: auto;
+        margin-top: 2;
+        align: right middle;
+    }
+
+    CreateAgentScreen #buttons Button {
+        margin-left: 1;
+    }
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._workspace_path = _load_last_workspace()
+
+    def compose(self) -> ComposeResult:
+        with Container(id="create-agent-root"):
+            yield Static("Create New Agent", id="create-agent-title")
+
+            yield Label("Agent Type", classes="section-label")
+            with RadioSet(id="agent-type"):
+                yield RadioButton("Claude", id="type-claude", value=True)
+                yield RadioButton("Codex", id="type-codex")
+                yield RadioButton("Opencode", id="type-opencode")
+                yield RadioButton("zsh", id="type-zsh")
+
+            with Vertical(id="workspace-section"):
+                yield Label("Workspace", classes="section-label")
+                with Horizontal(id="workspace-row"):
+                    yield Static(self._workspace_path, id="workspace-path")
+                    yield Button("Browse", id="browse-btn", variant="default")
+
+            with Horizontal(id="buttons"):
+                yield Button("Cancel", id="cancel")
+                yield Button("Create", id="create", variant="primary")
+
+    def on_mount(self) -> None:
+        self.query_one("#create", Button).focus()
+
+    def action_close(self) -> None:
+        self.dismiss(None)
+
+    def _update_workspace_display(self) -> None:
+        """Update the workspace path display."""
+        self.query_one("#workspace-path", Static).update(self._workspace_path)
+
+    async def _select_workspace(self) -> str | None:
+        """Open macOS folder picker and return selected path, or None if cancelled."""
+        default_path = self._workspace_path
+        default_path_escaped = default_path.replace('"', '\\"')
+        prompt = "Select workspace folder"
+        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
+
+    async def on_button_pressed(self, event: Button.Pressed) -> None:
+        button_id = event.button.id or ""
+
+        if button_id == "cancel":
+            self.dismiss(None)
+            return
+
+        if button_id == "browse-btn":
+            new_path = await self._select_workspace()
+            if new_path:
+                self._workspace_path = new_path
+                self._update_workspace_display()
+            return
+
+        if button_id == "create":
+            # Get selected agent type
+            radio_set = self.query_one("#agent-type", RadioSet)
+            pressed_button = radio_set.pressed_button
+            if pressed_button is None:
+                self.app.notify("Please select an agent type", severity="warning")
+                return
+
+            agent_type_map = {
+                "type-claude": "claude",
+                "type-codex": "codex",
+                "type-opencode": "opencode",
+                "type-zsh": "zsh",
+            }
+            agent_type = agent_type_map.get(pressed_button.id or "", "claude")
+
+            # Save the workspace path for next time
+            _save_last_workspace(self._workspace_path)
+
+            # Return the result
+            self.dismiss((agent_type, self._workspace_path))

realign/dashboard/screens/create_event.py

@@ -121,7 +121,9 @@ class CreateEventScreen(ModalScreen):
 
         self.query_one("#create", Button).disabled = True
         self.query_one("#cancel", Button).disabled = True
-        self.app.notify("Generating event (aline watcher event generate)...", title="Create Event", timeout=2)
+        self.app.notify(
+            "Generating event (aline watcher event generate)...", title="Create Event", timeout=2
+        )
 
         self._worker = self.run_worker(work, thread=True, exit_on_error=False)
 

realign/dashboard/screens/event_detail.py

@@ -284,7 +284,9 @@ class EventDetailScreen(ModalScreen):
         else:
             extra = result.get("stderr") or ""
             suffix = f": {extra}" if extra else ""
-            self.app.notify(f"Share export failed (exit {exit_code}){suffix}", title="Share", timeout=6)
+            self.app.notify(
+                f"Share export failed (exit {exit_code}){suffix}", title="Share", timeout=6
+            )
 
     def on_data_table_row_highlighted(self, event: DataTable.RowHighlighted) -> None:
         if event.data_table.id != "event-sessions-table":
@@ -365,7 +367,7 @@ class EventDetailScreen(ModalScreen):
                         "antigravity": "Antigravity",
                     }
                     source = source_map.get(session_type, session_type)
-                    project = (workspace.split("/")[-1] if workspace else "-")
+                    project = workspace.split("/")[-1] if workspace else "-"
 
                     self._sessions.append(
                         {
@@ -374,7 +376,9 @@ class EventDetailScreen(ModalScreen):
                             "source": source,
                             "project": project,
                             "turns": int(turn_count or 0),
-                            "total_turns": int(total_turns or 0) if total_turns is not None else None,
+                            "total_turns": (
+                                int(total_turns or 0) if total_turns is not None else None
+                            ),
                             "title": title,
                             "session_summary": session_summary,
                             "last_activity": last_activity,
@@ -397,7 +401,7 @@ class EventDetailScreen(ModalScreen):
                         "antigravity": "Antigravity",
                     }
                     source = source_map.get(session_type, session_type)
-                    project = (str(workspace).split("/")[-1] if workspace else "-")
+                    project = str(workspace).split("/")[-1] if workspace else "-"
 
                     self._sessions.append(
                         {
@@ -467,7 +471,9 @@ class EventDetailScreen(ModalScreen):
         selected_session_id: Optional[str] = None
         try:
             if table.row_count > 0:
-                selected_session_id = str(table.coordinate_to_cell_key(table.cursor_coordinate)[0].value)
+                selected_session_id = str(
+                    table.coordinate_to_cell_key(table.cursor_coordinate)[0].value
+                )
         except Exception:
             selected_session_id = None
         table.clear()
@@ -529,7 +535,9 @@ class EventDetailScreen(ModalScreen):
             "gemini": "Gemini",
             "antigravity": "Antigravity",
         }
-        source = source_map.get(record_type or "", record_type or session.get("source") or "unknown")
+        source = source_map.get(
+            record_type or "", record_type or session.get("source") or "unknown"
+        )
 
         title = record_title or session.get("title") or "(no title)"
         summary = record_summary or session.get("session_summary") or ""