aline-ai 0.5.8__py3-none-any.whl → 0.5.10__py3-none-any.whl

realign/dashboard/widgets/events_table.py

@@ -6,6 +6,7 @@ import json
 import os
 import shutil
 import subprocess
+import traceback
 from datetime import datetime
 from typing import Optional, Set
 from urllib.parse import urlparse
@@ -18,8 +19,11 @@ from textual.reactive import reactive
 from textual.worker import Worker, WorkerState
 from textual.widgets import Button, DataTable, Static
 
+from ...logging_config import setup_logger
 from .openable_table import OpenableDataTable
 
+logger = setup_logger("realign.dashboard.events", "dashboard.log")
+
 
 class EventsListTable(OpenableDataTable):
     """Events list table with multi-select behavior."""
@@ -123,38 +127,50 @@ class EventsTable(Container):
 
     def compose(self) -> ComposeResult:
         """Compose the events table layout."""
-        with Vertical(classes="action-section"):
-            yield Button(
-                "Load selected context to current agent",
-                id="load-context-btn",
-                variant="primary",
-                disabled=True,
-            )
-            yield Button(
-                "Share selected events to others",
-                id="share-event-btn",
-                variant="primary",
-                disabled=True,
-            )
-            yield Button(
-                "Import context from others",
-                id="share-import-btn",
-                variant="primary",
-            )
-        yield Static(id="section-header", classes="section-header")
-        with Container(classes="table-container"):
-            yield EventsListTable(id="events-table")
-        yield Static(id="pagination-info", classes="pagination-info")
-        yield Static(id="stats-info", classes="stats-info")
+        logger.debug("EventsTable.compose() started")
+        try:
+            with Vertical(classes="action-section"):
+                yield Button(
+                    "Load selected context to current agent",
+                    id="load-context-btn",
+                    variant="primary",
+                    disabled=True,
+                )
+                yield Button(
+                    "Share selected events to others",
+                    id="share-event-btn",
+                    variant="primary",
+                    disabled=True,
+                )
+                yield Button(
+                    "Import context from others",
+                    id="share-import-btn",
+                    variant="primary",
+                )
+            yield Static(id="section-header", classes="section-header")
+            with Container(classes="table-container"):
+                yield EventsListTable(id="events-table")
+            yield Static(id="pagination-info", classes="pagination-info")
+            yield Static(id="stats-info", classes="stats-info")
+            logger.debug("EventsTable.compose() completed")
+        except Exception as e:
+            logger.error(f"EventsTable.compose() failed: {e}\n{traceback.format_exc()}")
+            raise
 
     def on_mount(self) -> None:
         """Set up the table on mount."""
-        table = self.query_one("#events-table", EventsListTable)
-        table.owner = self
-        self._setup_table_columns(table)
-
-        # Calculate initial rows per page
-        self._calculate_rows_per_page()
+        logger.debug("EventsTable.on_mount() started")
+        try:
+            table = self.query_one("#events-table", EventsListTable)
+            table.owner = self
+            self._setup_table_columns(table)
+
+            # Calculate initial rows per page
+            self._calculate_rows_per_page()
+            logger.debug("EventsTable.on_mount() completed")
+        except Exception as e:
+            logger.error(f"EventsTable.on_mount() failed: {e}\n{traceback.format_exc()}")
+            raise
 
     def on_resize(self) -> None:
         """Handle window resize to adjust rows per page."""

realign/dashboard/widgets/terminal_panel.py

@@ -203,8 +203,8 @@ class TerminalPanel(Container, can_focus=True):
     }
 
     TerminalPanel .terminal-row Button.terminal-close {
-        width: 2;
-        min-width: 2;
+        width: 3;
+        min-width: 3;
         height: 2;
         margin-left: 1;
         padding: 0;
@@ -221,8 +221,8 @@ class TerminalPanel(Container, can_focus=True):
     }
 
     TerminalPanel .terminal-row Button.terminal-toggle {
-        width: 2;
-        min-width: 2;
+        width: 3;
+        min-width: 3;
         height: 2;
         margin-left: 1;
         padding: 0;
@@ -623,22 +623,24 @@ class TerminalPanel(Container, can_focus=True):
         """Wrap a command to run in a specific directory."""
         return f"cd {shlex.quote(directory)} && {command}"
 
-    def _on_create_agent_result(self, result: tuple[str, str] | None) -> None:
+    def _on_create_agent_result(self, result: tuple[str, str, bool] | None) -> None:
         """Handle the result from CreateAgentScreen modal."""
         if result is None:
             return
 
-        agent_type, workspace = result
+        agent_type, workspace, skip_permissions = result
         self.run_worker(
-            self._create_agent(agent_type, workspace),
+            self._create_agent(agent_type, workspace, skip_permissions=skip_permissions),
             group="terminal-panel-create",
             exclusive=True,
         )
 
-    async def _create_agent(self, agent_type: str, workspace: str) -> None:
+    async def _create_agent(
+        self, agent_type: str, workspace: str, *, skip_permissions: bool = False
+    ) -> None:
         """Create a new agent terminal based on the selected type and workspace."""
         if agent_type == "claude":
-            await self._create_claude_terminal(workspace)
+            await self._create_claude_terminal(workspace, skip_permissions=skip_permissions)
         elif agent_type == "codex":
             await self._create_codex_terminal(workspace)
         elif agent_type == "opencode":
@@ -647,7 +649,9 @@ class TerminalPanel(Container, can_focus=True):
             await self._create_zsh_terminal(workspace)
         await self.refresh_data()
 
-    async def _create_claude_terminal(self, workspace: str) -> None:
+    async def _create_claude_terminal(
+        self, workspace: str, *, skip_permissions: bool = False
+    ) -> None:
         """Create a new Claude terminal."""
         terminal_id = tmux_manager.new_terminal_id()
         context_id = tmux_manager.new_context_id("cc")
@@ -708,8 +712,11 @@ class TerminalPanel(Container, can_focus=True):
         except Exception:
             pass
 
+        claude_cmd = "claude"
+        if skip_permissions:
+            claude_cmd = "claude --dangerously-skip-permissions"
         command = self._command_in_directory(
-            tmux_manager.zsh_run_and_keep_open("claude"), workspace
+            tmux_manager.zsh_run_and_keep_open(claude_cmd), workspace
         )
         created = tmux_manager.create_inner_window(
             "cc",

realign/db/__init__.py

@@ -8,6 +8,47 @@ from .base import DatabaseInterface
 from .sqlite_db import SQLiteDatabase
 
 _DB_INSTANCE = None
+_MIGRATION_DONE = False
+
+
+def _auto_migrate_agents_data(db: SQLiteDatabase) -> None:
+    """Auto-migrate terminal.json and load.json data to SQLite (runs once).
+
+    This is triggered automatically when the schema is upgraded to V15.
+    Uses a marker file to avoid running multiple times.
+    """
+    global _MIGRATION_DONE
+    if _MIGRATION_DONE:
+        return
+
+    # Check marker file
+    marker_path = Path.home() / ".aline" / ".agents_migrated_v15"
+    if marker_path.exists():
+        _MIGRATION_DONE = True
+        return
+
+    # Skip during tests
+    if os.getenv("PYTEST_CURRENT_TEST"):
+        _MIGRATION_DONE = True
+        return
+
+    try:
+        from .migrate_agents import migrate_terminal_json, migrate_load_json
+
+        # Run migrations silently (no dry_run)
+        agents_count = migrate_terminal_json(db, dry_run=False, silent=True)
+        contexts_count = migrate_load_json(db, dry_run=False, silent=True)
+
+        # Create marker file
+        marker_path.parent.mkdir(parents=True, exist_ok=True)
+        marker_path.write_text(
+            f"Migrated: {agents_count} agents, {contexts_count} contexts\n"
+        )
+
+        _MIGRATION_DONE = True
+    except Exception:
+        # Don't fail if migration fails - JSON fallback will still work
+        _MIGRATION_DONE = True
 
 
 def get_database(
@@ -54,4 +95,7 @@ def get_database(
         _DB_INSTANCE = SQLiteDatabase(db_path, connect_timeout_seconds=timeout)
         _DB_INSTANCE.initialize()
 
+        # Auto-migrate JSON data to SQLite (runs once after V15 upgrade)
+        _auto_migrate_agents_data(_DB_INSTANCE)
+
     return _DB_INSTANCE

realign/db/base.py

@@ -107,6 +107,42 @@ class EventRecord:
     creator_id: Optional[str] = None
 
 
+@dataclass
+class AgentRecord:
+    """Represents a terminal/agent mapping (V15: replaces terminal.json)."""
+
+    id: str  # terminal_id (UUID)
+    provider: str  # 'claude', 'codex', 'opencode', 'zsh'
+    session_type: str
+    created_at: datetime
+    updated_at: datetime
+    session_id: Optional[str] = None  # FK to sessions.id
+    context_id: Optional[str] = None
+    transcript_path: Optional[str] = None
+    cwd: Optional[str] = None
+    project_dir: Optional[str] = None
+    status: str = "active"  # 'active', 'stopped'
+    attention: Optional[str] = None  # 'permission_request', 'stop', or None
+    source: Optional[str] = None
+    creator_name: Optional[str] = None
+    creator_id: Optional[str] = None
+
+
+@dataclass
+class AgentContextRecord:
+    """Represents a context entry (V15: replaces load.json)."""
+
+    id: str  # context_id
+    created_at: datetime
+    updated_at: datetime
+    workspace: Optional[str] = None
+    loaded_at: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+    # Populated when reading (from M2M tables)
+    session_ids: Optional[List[str]] = None
+    event_ids: Optional[List[str]] = None
+
+
 class DatabaseInterface(ABC):
     """Abstract interface for ReAlign storage backend."""
 

realign/db/migrate_agents.py

@@ -0,0 +1,297 @@
+"""Migration script to import terminal.json and load.json data into SQLite.
+
+This script migrates:
+- ~/.aline/terminal.json -> agents table
+- ~/.aline/load.json -> agent_contexts, agent_context_sessions, agent_context_events tables
+
+Usage:
+    python -m realign.db.migrate_agents [--backup] [--dry-run]
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+def migrate_terminal_json(db, dry_run: bool = False, silent: bool = False) -> int:
+    """Migrate terminal.json to agents table.
+
+    Args:
+        db: Database instance
+        dry_run: If True, don't actually migrate
+        silent: If True, don't print any output
+
+    Returns:
+        Number of agents migrated
+    """
+    path = Path.home() / ".aline" / "terminal.json"
+    if not path.exists():
+        if not silent:
+            print(f"[migrate] terminal.json not found at {path}, skipping")
+        return 0
+
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as e:
+        if not silent:
+            print(f"[migrate] Failed to read terminal.json: {e}")
+        return 0
+
+    terminals = payload.get("terminals", {})
+    if not isinstance(terminals, dict):
+        if not silent:
+            print("[migrate] terminal.json has no 'terminals' dict, skipping")
+        return 0
+
+    migrated = 0
+    for terminal_id, data in terminals.items():
+        if not isinstance(terminal_id, str) or not isinstance(data, dict):
+            continue
+
+        provider = data.get("provider", "unknown")
+        session_type = data.get("session_type", provider)
+        session_id = data.get("session_id") or None
+        transcript_path = data.get("transcript_path") or None
+        cwd = data.get("cwd") or None
+        project_dir = data.get("project_dir") or None
+        source = data.get("source") or None
+        context_id = data.get("context_id") or None
+        attention = data.get("attention") or None
+
+        if dry_run:
+            if not silent:
+                print(f"[dry-run] Would migrate agent: {terminal_id[:8]}... ({provider})")
+            migrated += 1
+            continue
+
+        try:
+            existing = db.get_agent_by_id(terminal_id)
+            if existing:
+                if not silent:
+                    print(f"[migrate] Agent {terminal_id[:8]}... already exists, skipping")
+                continue
+
+            db.get_or_create_agent(
+                terminal_id,
+                provider=provider,
+                session_type=session_type,
+                session_id=session_id,
+                context_id=context_id,
+                transcript_path=transcript_path,
+                cwd=cwd,
+                project_dir=project_dir,
+                source=source,
+                attention=attention,
+            )
+            if not silent:
+                print(f"[migrate] Migrated agent: {terminal_id[:8]}... ({provider})")
+            migrated += 1
+        except Exception as e:
+            if not silent:
+                print(f"[migrate] Failed to migrate agent {terminal_id[:8]}...: {e}")
+
+    return migrated
+
+
+def migrate_load_json(db, dry_run: bool = False, silent: bool = False) -> int:
+    """Migrate load.json to agent_contexts tables.
+
+    Args:
+        db: Database instance
+        dry_run: If True, don't actually migrate
+        silent: If True, don't print any output
+
+    Returns:
+        Number of contexts migrated
+    """
+    path = Path.home() / ".aline" / "load.json"
+    if not path.exists():
+        if not silent:
+            print(f"[migrate] load.json not found at {path}, skipping")
+        return 0
+
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except Exception as e:
+        if not silent:
+            print(f"[migrate] Failed to read load.json: {e}")
+        return 0
+
+    contexts = payload.get("contexts", [])
+    if not isinstance(contexts, list):
+        if not silent:
+            print("[migrate] load.json has no 'contexts' list, skipping")
+        return 0
+
+    migrated = 0
+    for ctx_data in contexts:
+        if not isinstance(ctx_data, dict):
+            continue
+
+        context_id = ctx_data.get("context_id")
+        if not context_id:
+            # Generate context_id from workspace if not present
+            workspace = ctx_data.get("workspace")
+            if workspace:
+                # Create a deterministic ID from workspace
+                import hashlib
+
+                context_id = f"ws-{hashlib.sha256(workspace.encode()).hexdigest()[:12]}"
+            else:
+                continue
+
+        workspace = ctx_data.get("workspace")
+        loaded_at = ctx_data.get("loaded_at")
+        context_sessions = ctx_data.get("context_sessions", [])
+        context_events = ctx_data.get("context_events", [])
+
+        if dry_run:
+            if not silent:
+                print(
+                    f"[dry-run] Would migrate context: {context_id} "
+                    f"(sessions={len(context_sessions)}, events={len(context_events)})"
+                )
+            migrated += 1
+            continue
+
+        try:
+            existing = db.get_agent_context_by_id(context_id)
+            if existing:
+                if not silent:
+                    print(f"[migrate] Context {context_id} already exists, updating links")
+            else:
+                db.get_or_create_agent_context(
+                    context_id,
+                    workspace=workspace,
+                    loaded_at=loaded_at,
+                )
+                if not silent:
+                    print(f"[migrate] Created context: {context_id}")
+
+            # Update session links (silently skips if session not in DB)
+            if context_sessions:
+                for session_id in context_sessions:
+                    db.link_session_to_agent_context(context_id, session_id)
+                if not silent:
+                    print(f"[migrate] Linked {len(context_sessions)} sessions to {context_id}")
+
+            # Update event links (silently skips if event not in DB)
+            if context_events:
+                for event_id in context_events:
+                    db.link_event_to_agent_context(context_id, event_id)
+                if not silent:
+                    print(f"[migrate] Linked {len(context_events)} events to {context_id}")
+
+            migrated += 1
+        except Exception as e:
+            if not silent:
+                print(f"[migrate] Failed to migrate context {context_id}: {e}")
+
+    return migrated
+
+
+def backup_json_files() -> bool:
+    """Create backup of JSON files.
+
+    Returns:
+        True if backup was successful or files don't exist
+    """
+    files = [
+        Path.home() / ".aline" / "terminal.json",
+        Path.home() / ".aline" / "load.json",
+    ]
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    for path in files:
+        if not path.exists():
+            continue
+
+        backup_path = path.with_suffix(f".json.bak.{timestamp}")
+        try:
+            backup_path.write_text(path.read_text(encoding="utf-8"), encoding="utf-8")
+            print(f"[backup] Created backup: {backup_path}")
+        except Exception as e:
+            print(f"[backup] Failed to backup {path}: {e}")
+            return False
+
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Migrate terminal.json and load.json to SQLite database"
+    )
+    parser.add_argument(
+        "--backup",
+        action="store_true",
+        help="Create backup of JSON files before migration",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be migrated without actually doing it",
+    )
+    parser.add_argument(
+        "--db-path",
+        type=str,
+        default=str(Path.home() / ".aline" / "realign.db"),
+        help="Path to SQLite database",
+    )
+
+    args = parser.parse_args()
+
+    print("=" * 60)
+    print("Aline Agents Migration: JSON -> SQLite")
+    print("=" * 60)
+
+    if args.dry_run:
+        print("[mode] DRY RUN - no changes will be made")
+
+    # Backup if requested
+    if args.backup and not args.dry_run:
+        print("\n[step] Creating backups...")
+        if not backup_json_files():
+            print("[error] Backup failed, aborting migration")
+            sys.exit(1)
+
+    # Initialize database
+    if not args.dry_run:
+        from .sqlite_db import SQLiteDatabase
+
+        print(f"\n[step] Initializing database at {args.db_path}")
+        db = SQLiteDatabase(args.db_path)
+        if not db.initialize():
+            print("[error] Database initialization failed")
+            sys.exit(1)
+    else:
+        db = None
+
+    # Migrate terminal.json
+    print("\n[step] Migrating terminal.json -> agents table")
+    agents_migrated = migrate_terminal_json(db, dry_run=args.dry_run)
+    print(f"[result] Migrated {agents_migrated} agents")
+
+    # Migrate load.json
+    print("\n[step] Migrating load.json -> agent_contexts tables")
+    contexts_migrated = migrate_load_json(db, dry_run=args.dry_run)
+    print(f"[result] Migrated {contexts_migrated} contexts")
+
+    # Cleanup
+    if db:
+        db.close()
+
+    print("\n" + "=" * 60)
+    print("Migration complete!")
+    print(f"  Agents migrated: {agents_migrated}")
+    print(f"  Contexts migrated: {contexts_migrated}")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()