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

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()

realign/db/schema.py

@@ -52,9 +52,15 @@ Schema V14: Share reuse per event.
 - events.share_id: Share ID on server
 - events.share_admin_token: Admin token for extending expiry
 - events.share_expiry_at: Last known expiry timestamp
+
+Schema V15: Agents and contexts tables (replaces terminal.json and load.json).
+- agents table: terminal_id -> session mapping (replaces terminal.json)
+- agent_contexts table: context definitions (replaces load.json)
+- agent_context_sessions table: M2M context-session links
+- agent_context_events table: M2M context-event links
 """
 
-SCHEMA_VERSION = 14
+SCHEMA_VERSION = 15
 
 FTS_EVENTS_SCRIPTS = [
     # Full Text Search for Events
@@ -246,6 +252,63 @@ INIT_SCRIPTS = [
     """,
     "CREATE INDEX IF NOT EXISTS idx_event_sessions_event ON event_sessions(event_id);",
     "CREATE INDEX IF NOT EXISTS idx_event_sessions_session ON event_sessions(session_id);",
+    # Agents table (V15: replaces terminal.json)
+    """
+    CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,              -- terminal_id (UUID)
+        provider TEXT NOT NULL,           -- 'claude', 'codex', 'opencode', 'zsh'
+        session_type TEXT NOT NULL,
+        session_id TEXT,                  -- FK to sessions.id (nullable, may not exist yet)
+        context_id TEXT,
+        transcript_path TEXT,
+        cwd TEXT,
+        project_dir TEXT,
+        status TEXT DEFAULT 'active',     -- 'active', 'stopped'
+        attention TEXT,                   -- 'permission_request', 'stop', NULL
+        source TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        creator_name TEXT,
+        creator_id TEXT
+    );
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_agents_session ON agents(session_id);",
+    "CREATE INDEX IF NOT EXISTS idx_agents_context ON agents(context_id);",
+    "CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status);",
+    # Agent contexts table (V15: replaces load.json)
+    """
+    CREATE TABLE IF NOT EXISTS agent_contexts (
+        id TEXT PRIMARY KEY,              -- context_id
+        workspace TEXT,
+        loaded_at TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        metadata TEXT
+    );
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_agent_contexts_workspace ON agent_contexts(workspace);",
+    # Agent context sessions (M2M)
+    """
+    CREATE TABLE IF NOT EXISTS agent_context_sessions (
+        context_id TEXT NOT NULL REFERENCES agent_contexts(id) ON DELETE CASCADE,
+        session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+        added_at TEXT DEFAULT (datetime('now')),
+        PRIMARY KEY (context_id, session_id)
+    );
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_agent_context_sessions_context ON agent_context_sessions(context_id);",
+    "CREATE INDEX IF NOT EXISTS idx_agent_context_sessions_session ON agent_context_sessions(session_id);",
+    # Agent context events (M2M)
+    """
+    CREATE TABLE IF NOT EXISTS agent_context_events (
+        context_id TEXT NOT NULL REFERENCES agent_contexts(id) ON DELETE CASCADE,
+        event_id TEXT NOT NULL REFERENCES events(id) ON DELETE CASCADE,
+        added_at TEXT DEFAULT (datetime('now')),
+        PRIMARY KEY (context_id, event_id)
+    );
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_agent_context_events_context ON agent_context_events(context_id);",
+    "CREATE INDEX IF NOT EXISTS idx_agent_context_events_event ON agent_context_events(event_id);",
     *FTS_EVENTS_SCRIPTS,
 ]
 
@@ -403,6 +466,66 @@ MIGRATION_V13_TO_V14 = [
     "ALTER TABLE events ADD COLUMN share_expiry_at TEXT;",
 ]
 
+MIGRATION_V14_TO_V15 = [
+    # Agents table (replaces terminal.json)
+    """
+    CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,
+        provider TEXT NOT NULL,
+        session_type TEXT NOT NULL,
+        session_id TEXT,
+        context_id TEXT,
+        transcript_path TEXT,
+        cwd TEXT,
+        project_dir TEXT,
+        status TEXT DEFAULT 'active',
+        attention TEXT,
+        source TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        creator_name TEXT,
+        creator_id TEXT
+    );
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_agents_session ON agents(session_id);",
+    "CREATE INDEX IF NOT EXISTS idx_agents_context ON agents(context_id);",
+    "CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status);",
+    # Agent contexts table (replaces load.json)
+    """
+    CREATE TABLE IF NOT EXISTS agent_contexts (
+        id TEXT PRIMARY KEY,
+        workspace TEXT,
+        loaded_at TEXT,
+        created_at TEXT DEFAULT (datetime('now')),
+        updated_at TEXT DEFAULT (datetime('now')),
+        metadata TEXT
+    );
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_agent_contexts_workspace ON agent_contexts(workspace);",
+    # Agent context sessions (M2M)
+    """
+    CREATE TABLE IF NOT EXISTS agent_context_sessions (
+        context_id TEXT NOT NULL REFERENCES agent_contexts(id) ON DELETE CASCADE,
+        session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+        added_at TEXT DEFAULT (datetime('now')),
+        PRIMARY KEY (context_id, session_id)
+    );
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_agent_context_sessions_context ON agent_context_sessions(context_id);",
+    "CREATE INDEX IF NOT EXISTS idx_agent_context_sessions_session ON agent_context_sessions(session_id);",
+    # Agent context events (M2M)
+    """
+    CREATE TABLE IF NOT EXISTS agent_context_events (
+        context_id TEXT NOT NULL REFERENCES agent_contexts(id) ON DELETE CASCADE,
+        event_id TEXT NOT NULL REFERENCES events(id) ON DELETE CASCADE,
+        added_at TEXT DEFAULT (datetime('now')),
+        PRIMARY KEY (context_id, event_id)
+    );
+    """,
+    "CREATE INDEX IF NOT EXISTS idx_agent_context_events_context ON agent_context_events(context_id);",
+    "CREATE INDEX IF NOT EXISTS idx_agent_context_events_event ON agent_context_events(event_id);",
+]
+
 
 def get_migration_scripts(from_version: int, to_version: int) -> list:
     """Get migration scripts for upgrading between versions."""
@@ -453,4 +576,7 @@ def get_migration_scripts(from_version: int, to_version: int) -> list:
     if from_version < 14 and to_version >= 14:
         scripts.extend(MIGRATION_V13_TO_V14)
 
+    if from_version < 15 and to_version >= 15:
+        scripts.extend(MIGRATION_V14_TO_V15)
+
     return scripts