aline-ai 0.6.5__py3-none-any.whl → 0.6.7__py3-none-any.whl

realign/db/sqlite_db.py

@@ -21,7 +21,9 @@ from .base import (
     EventRecord,
     LockRecord,
     AgentRecord,
+    AgentInfoRecord,
     AgentContextRecord,
+    WindowLinkRecord,
     UserRecord,
 )
 from .schema import (
@@ -293,6 +295,7 @@ class SQLiteDatabase(DatabaseInterface):
         started_at: datetime,
         workspace_path: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
+        agent_id: Optional[str] = None,
     ) -> SessionRecord:
         """Get existing session or create new one."""
         conn = self._get_connection()
@@ -317,8 +320,8 @@ class SQLiteDatabase(DatabaseInterface):
             INSERT INTO sessions (
                 id, session_file_path, session_type, workspace_path,
                 started_at, last_activity_at, created_at, updated_at, metadata,
-                created_by
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                created_by, agent_id
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """,
             (
                 session_id,
@@ -331,6 +334,7 @@ class SQLiteDatabase(DatabaseInterface):
                 now,
                 metadata_json,
                 config.uid,
+                agent_id,
             ),
         )
         conn.commit()
@@ -353,7 +357,17 @@ class SQLiteDatabase(DatabaseInterface):
             metadata=metadata or {},
             workspace_path=workspace_path,
             created_by=config.uid,
+            agent_id=agent_id,
+        )
+
+    def update_session_agent_id(self, session_id: str, agent_id: Optional[str]) -> None:
+        """Set or update the agent_id on an existing session (V19)."""
+        conn = self._get_connection()
+        conn.execute(
+            "UPDATE sessions SET agent_id = ?, updated_at = ? WHERE id = ?",
+            (agent_id, datetime.now(), session_id),
         )
+        conn.commit()
 
     def update_session_activity(self, session_id: str, last_activity_at: datetime) -> None:
         """Update last activity timestamp."""
@@ -557,6 +571,30 @@ class SQLiteDatabase(DatabaseInterface):
         )
         return [self._row_to_session(row) for row in cursor.fetchall()]
 
+    def get_sessions_by_agent_id(self, agent_id: str, limit: int = 1000) -> List[SessionRecord]:
+        """Get all sessions linked to an agent.
+
+        Args:
+            agent_id: The agent_info ID
+            limit: Maximum number of sessions to return
+
+        Returns:
+            List of SessionRecord objects for this agent
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        try:
+            cursor.execute(
+                """SELECT * FROM sessions
+                   WHERE agent_id = ?
+                   ORDER BY last_activity_at DESC
+                   LIMIT ?""",
+                (agent_id, limit),
+            )
+            return [self._row_to_session(row) for row in cursor.fetchall()]
+        except sqlite3.OperationalError:
+            return []
+
     def get_turn_content(self, turn_id: str) -> Optional[str]:
         """Get the JSONL content for a turn."""
         conn = self._get_connection()
@@ -973,6 +1011,7 @@ class SQLiteDatabase(DatabaseInterface):
         expected_turns: Optional[int] = None,
         skip_dedup: bool = False,
         no_track: bool = False,
+        agent_id: Optional[str] = None,
     ) -> str:
         session_id = session_file_path.stem
         dedupe_key = f"turn:{session_id}:{int(turn_number)}"
@@ -991,6 +1030,8 @@ class SQLiteDatabase(DatabaseInterface):
             payload["skip_dedup"] = True
         if no_track:
             payload["no_track"] = True
+        if agent_id:
+            payload["agent_id"] = agent_id
 
         # For append-only session formats (Claude/Codex/Gemini), a turn is immutable once completed.
         # Avoid re-running already-done turn jobs on repeated enqueue attempts.
@@ -1033,6 +1074,17 @@ class SQLiteDatabase(DatabaseInterface):
             requeue_done=True,
         )
 
+    def enqueue_agent_description_job(self, *, agent_id: str) -> str:
+        dedupe_key = f"agent_desc:{agent_id}"
+        payload: Dict[str, Any] = {"agent_id": agent_id}
+        return self.enqueue_job(
+            kind="agent_description",
+            dedupe_key=dedupe_key,
+            payload=payload,
+            priority=12,
+            requeue_done=True,
+        )
+
     def claim_next_job(
         self,
         *,
@@ -2344,6 +2396,92 @@ class SQLiteDatabase(DatabaseInterface):
         except sqlite3.OperationalError:
             return []
 
+    def insert_window_link(
+        self,
+        *,
+        terminal_id: str,
+        agent_id: Optional[str],
+        session_id: Optional[str],
+        provider: Optional[str],
+        source: Optional[str],
+        ts: Optional[float] = None,
+    ) -> None:
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        ts_value = ts if ts is not None else time.time()
+        try:
+            cursor.execute(
+                """
+                INSERT INTO windowlink (
+                    terminal_id, agent_id, session_id, provider, source, ts
+                ) VALUES (?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    terminal_id,
+                    agent_id,
+                    session_id,
+                    provider,
+                    source,
+                    float(ts_value),
+                ),
+            )
+            conn.commit()
+        except sqlite3.OperationalError:
+            conn.rollback()
+
+    def list_latest_window_links(
+        self, *, agent_id: Optional[str] = None, limit: int = 1000
+    ) -> List[WindowLinkRecord]:
+        conn = self._get_connection()
+        cursor = conn.cursor()
+        params: List[Any] = []
+        where_clause = ""
+        if agent_id:
+            where_clause = "WHERE agent_id = ?"
+            params.append(agent_id)
+        params.append(limit)
+        try:
+            cursor.execute(
+                f"""
+                SELECT terminal_id, agent_id, session_id, provider, source, ts, created_at
+                FROM (
+                    SELECT terminal_id,
+                           agent_id,
+                           session_id,
+                           provider,
+                           source,
+                           ts,
+                           created_at,
+                           ROW_NUMBER() OVER (
+                               PARTITION BY terminal_id
+                               ORDER BY ts DESC, id DESC
+                           ) AS rn
+                    FROM windowlink
+                    {where_clause}
+                ) AS ranked
+                WHERE rn = 1
+                LIMIT ?
+                """,
+                params,
+            )
+            rows = cursor.fetchall()
+            out: List[WindowLinkRecord] = []
+            for row in rows:
+                out.append(
+                    WindowLinkRecord(
+                        terminal_id=row[0],
+                        agent_id=row[1],
+                        session_id=row[2],
+                        provider=row[3],
+                        source=row[4],
+                        ts=row[5],
+                        created_at=self._parse_datetime(row[6]) if row[6] else None,
+                    )
+                )
+            return out
+        except sqlite3.OperationalError:
+            return []
+
     def delete_agent(self, agent_id: str) -> bool:
         """Delete an agent by ID."""
         conn = self._get_connection()
@@ -2770,6 +2908,13 @@ class SQLiteDatabase(DatabaseInterface):
         except (IndexError, KeyError):
             pass
 
+        # V19: agent association
+        agent_id = None
+        try:
+            agent_id = row["agent_id"]
+        except (IndexError, KeyError):
+            pass
+
         return SessionRecord(
             id=row["id"],
             session_file_path=Path(row["session_file_path"]),
@@ -2790,6 +2935,7 @@ class SQLiteDatabase(DatabaseInterface):
             shared_by=shared_by,
             total_turns=total_turns,
             total_turns_mtime=total_turns_mtime,
+            agent_id=agent_id,
         )
 
     def _row_to_turn(self, row: sqlite3.Row) -> TurnRecord:
@@ -3015,3 +3161,215 @@ class SQLiteDatabase(DatabaseInterface):
         except sqlite3.OperationalError:
             pass
         return None
+
+    # -------------------------------------------------------------------------
+    # Agent info table methods (Schema V20)
+    # -------------------------------------------------------------------------
+
+    def _row_to_agent_info(self, row: sqlite3.Row) -> AgentInfoRecord:
+        """Convert a database row to an AgentInfoRecord."""
+        keys = row.keys()
+        visibility = "visible"
+        try:
+            if "visibility" in keys:
+                visibility = row["visibility"] or "visible"
+        except Exception:
+            visibility = "visible"
+
+        def _safe_get(key: str, default=None):
+            try:
+                return row[key] if key in keys else default
+            except Exception:
+                return default
+
+        return AgentInfoRecord(
+            id=row["id"],
+            name=row["name"],
+            description=row["description"] or "",
+            created_at=self._parse_datetime(row["created_at"]),
+            updated_at=self._parse_datetime(row["updated_at"]),
+            visibility=visibility,
+            share_id=_safe_get("share_id"),
+            share_url=_safe_get("share_url"),
+            share_admin_token=_safe_get("share_admin_token"),
+            share_contributor_token=_safe_get("share_contributor_token"),
+            share_expiry_at=_safe_get("share_expiry_at"),
+            last_synced_at=_safe_get("last_synced_at"),
+            sync_version=_safe_get("sync_version", 0) or 0,
+        )
+
+    def get_or_create_agent_info(
+        self, agent_id: str, name: Optional[str] = None
+    ) -> AgentInfoRecord:
+        """Get existing agent info or create a new one.
+
+        Args:
+            agent_id: UUID for the agent.
+            name: Display name (if None, caller should provide a generated name).
+        """
+        conn = self._get_connection()
+        cursor = conn.cursor()
+
+        try:
+            cursor.execute("SELECT * FROM agent_info WHERE id = ?", (agent_id,))
+            row = cursor.fetchone()
+            if row:
+                return self._row_to_agent_info(row)
+        except sqlite3.OperationalError:
+            pass
+
+        display_name = name or agent_id[:8]
+        cursor.execute(
+            """
+            INSERT INTO agent_info (id, name, description, visibility, created_at, updated_at)
+            VALUES (?, ?, '', 'visible', datetime('now'), datetime('now'))
+            """,
+            (agent_id, display_name),
+        )
+        conn.commit()
+
+        cursor.execute("SELECT * FROM agent_info WHERE id = ?", (agent_id,))
+        row = cursor.fetchone()
+        return self._row_to_agent_info(row)
+
+    def get_agent_info(self, agent_id: str) -> Optional[AgentInfoRecord]:
+        """Get agent info by ID, or None if not found."""
+        conn = self._get_connection()
+        try:
+            cursor = conn.execute("SELECT * FROM agent_info WHERE id = ?", (agent_id,))
+            row = cursor.fetchone()
+            if row:
+                return self._row_to_agent_info(row)
+        except sqlite3.OperationalError:
+            pass
+        return None
+
+    def update_agent_info(
+        self,
+        agent_id: str,
+        *,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        visibility: Optional[str] = None,
+    ) -> Optional[AgentInfoRecord]:
+        """Update agent info fields. Returns updated record or None if not found."""
+        conn = self._get_connection()
+        sets: list[str] = []
+        params: list[Any] = []
+
+        if name is not None:
+            sets.append("name = ?")
+            params.append(name)
+        if description is not None:
+            sets.append("description = ?")
+            params.append(description)
+        if visibility is not None:
+            sets.append("visibility = ?")
+            params.append(visibility)
+
+        if not sets:
+            return self.get_agent_info(agent_id)
+
+        sets.append("updated_at = datetime('now')")
+        params.append(agent_id)
+
+        try:
+            conn.execute(
+                f"UPDATE agent_info SET {', '.join(sets)} WHERE id = ?",
+                params,
+            )
+            conn.commit()
+        except sqlite3.OperationalError:
+            return None
+
+        return self.get_agent_info(agent_id)
+
+    def list_agent_info(self, *, include_invisible: bool = False) -> list[AgentInfoRecord]:
+        """List agent info records, ordered by created_at descending."""
+        conn = self._get_connection()
+        try:
+            if include_invisible:
+                cursor = conn.execute("SELECT * FROM agent_info ORDER BY created_at DESC")
+            else:
+                try:
+                    cursor = conn.execute(
+                        "SELECT * FROM agent_info WHERE visibility = 'visible' ORDER BY created_at DESC"
+                    )
+                except sqlite3.OperationalError:
+                    cursor = conn.execute("SELECT * FROM agent_info ORDER BY created_at DESC")
+            return [self._row_to_agent_info(row) for row in cursor.fetchall()]
+        except sqlite3.OperationalError:
+            return []
+
+    def update_agent_sync_metadata(
+        self,
+        agent_id: str,
+        *,
+        share_id: Optional[str] = None,
+        share_url: Optional[str] = None,
+        share_admin_token: Optional[str] = None,
+        share_contributor_token: Optional[str] = None,
+        share_expiry_at: Optional[str] = None,
+        last_synced_at: Optional[str] = None,
+        sync_version: Optional[int] = None,
+    ) -> Optional[AgentInfoRecord]:
+        """Update sync-related metadata on an agent_info record."""
+        conn = self._get_connection()
+        sets: list[str] = []
+        params: list[Any] = []
+
+        if share_id is not None:
+            sets.append("share_id = ?")
+            params.append(share_id)
+        if share_url is not None:
+            sets.append("share_url = ?")
+            params.append(share_url)
+        if share_admin_token is not None:
+            sets.append("share_admin_token = ?")
+            params.append(share_admin_token)
+        if share_contributor_token is not None:
+            sets.append("share_contributor_token = ?")
+            params.append(share_contributor_token)
+        if share_expiry_at is not None:
+            sets.append("share_expiry_at = ?")
+            params.append(share_expiry_at)
+        if last_synced_at is not None:
+            sets.append("last_synced_at = ?")
+            params.append(last_synced_at)
+        if sync_version is not None:
+            sets.append("sync_version = ?")
+            params.append(sync_version)
+
+        if not sets:
+            return self.get_agent_info(agent_id)
+
+        sets.append("updated_at = datetime('now')")
+        params.append(agent_id)
+
+        try:
+            conn.execute(
+                f"UPDATE agent_info SET {', '.join(sets)} WHERE id = ?",
+                params,
+            )
+            conn.commit()
+        except sqlite3.OperationalError:
+            return None
+
+        return self.get_agent_info(agent_id)
+
+    def get_agent_content_hashes(self, agent_id: str) -> set[str]:
+        """Return all content_hash values for turns in this agent's sessions."""
+        conn = self._get_connection()
+        try:
+            cursor = conn.execute(
+                """
+                SELECT DISTINCT t.content_hash
+                FROM turns t
+                JOIN sessions s ON t.session_id = s.id
+                WHERE s.agent_id = ?
+                """,
+                (agent_id,),
+            )
+            return {row["content_hash"] for row in cursor.fetchall()}
+        except sqlite3.OperationalError:
+            return set()

realign/events/agent_summarizer.py

@@ -0,0 +1,157 @@
+"""Agent description generation from session summaries using LLM."""
+
+import logging
+from pathlib import Path
+from typing import List, Optional
+
+from ..db.sqlite_db import SQLiteDatabase
+from ..db.base import SessionRecord
+from ..db.locks import lease_lock, lock_key_for_agent_description, make_lock_owner
+from ..llm_client import call_llm_cloud
+
+logger = logging.getLogger(__name__)
+
+
+def schedule_agent_description_update(db: SQLiteDatabase, agent_id: str) -> None:
+    """
+    Enqueue an agent description update job (durable).
+
+    Call this after a session summary is updated for an agent-linked session.
+
+    Args:
+        db: Database instance
+        agent_id: ID of the agent to update
+    """
+    try:
+        db.enqueue_agent_description_job(agent_id=agent_id)
+        logger.debug(f"Enqueued agent description job for agent_id={agent_id}")
+    except Exception as e:
+        logger.debug(f"Failed to enqueue agent description job, falling back: {e}")
+        force_update_agent_description(db, agent_id)
+
+
+def force_update_agent_description(db: SQLiteDatabase, agent_id: str) -> None:
+    """
+    Immediately update agent description, bypassing the job queue.
+
+    Args:
+        db: Database instance
+        agent_id: ID of the agent to update
+    """
+    _update_agent_description(db, agent_id)
+
+
+def _update_agent_description(db: SQLiteDatabase, agent_id: str) -> None:
+    """
+    Actually perform the agent description update.
+
+    Args:
+        db: Database instance
+        agent_id: ID of the agent to update
+    """
+    logger.info(f"Updating agent description for agent_id={agent_id}")
+
+    owner = make_lock_owner("agent_description")
+    lock_key = lock_key_for_agent_description(agent_id)
+
+    with lease_lock(
+        db,
+        lock_key,
+        owner=owner,
+        ttl_seconds=10 * 60,  # 10 minutes
+        wait_timeout_seconds=0.0,
+    ) as acquired:
+        if not acquired:
+            logger.debug(f"Agent description lock held by another process: agent_id={agent_id}")
+            return
+
+        sessions = db.get_sessions_by_agent_id(agent_id)
+        if not sessions:
+            logger.warning(f"No sessions found for agent_id={agent_id}")
+            return
+
+        # Filter to sessions with non-empty title or summary
+        sessions_with_content = [
+            s for s in sessions if s.session_title or s.session_summary
+        ]
+        if not sessions_with_content:
+            logger.warning(f"No sessions with summaries for agent_id={agent_id}")
+            return
+
+        description = _generate_agent_description_llm(sessions_with_content)
+        db.update_agent_info(agent_id, description=description)
+        logger.info(
+            f"Agent description updated: '{description[:60]}...' for agent_id={agent_id}"
+        )
+
+
+def _generate_agent_description_llm(sessions: List[SessionRecord]) -> str:
+    """
+    Use LLM to generate an agent description from all its sessions.
+
+    Args:
+        sessions: List of sessions linked to the agent
+
+    Returns:
+        Description string
+    """
+    if not sessions:
+        return ""
+
+    # Build sessions payload
+    sessions_data = []
+    for i, session in enumerate(sessions):
+        sessions_data.append(
+            {
+                "session_number": i + 1,
+                "title": session.session_title or f"Session {session.id[:8]}",
+                "summary": session.session_summary or "(no summary)",
+            }
+        )
+
+    # Try cloud provider
+    try:
+        from ..auth import is_logged_in
+
+        if is_logged_in():
+            logger.debug("Attempting cloud LLM for agent description")
+            custom_prompt = None
+            user_prompt_path = Path.home() / ".aline" / "prompts" / "agent_description.md"
+            try:
+                if user_prompt_path.exists():
+                    custom_prompt = user_prompt_path.read_text(encoding="utf-8").strip()
+            except Exception:
+                pass
+
+            _, result = call_llm_cloud(
+                task="agent_description",
+                payload={"sessions": sessions_data},
+                custom_prompt=custom_prompt,
+                silent=True,
+            )
+
+            if result:
+                description = result.get("description", "")
+                logger.info(f"Cloud LLM agent description success: {description[:60]}...")
+                return description
+            else:
+                logger.warning("Cloud LLM agent description failed, using fallback")
+                return _fallback_agent_description(sessions)
+    except ImportError:
+        logger.debug("Auth module not available, skipping cloud LLM")
+
+    logger.warning("Not logged in, cannot use cloud LLM for agent description")
+    return _fallback_agent_description(sessions)
+
+
+def _fallback_agent_description(sessions: List[SessionRecord]) -> str:
+    """Fallback when LLM fails: simple concatenation of recent session summaries."""
+    summaries = [s.session_summary for s in sessions if s.session_summary]
+    if not summaries:
+        titles = [s.session_title for s in sessions if s.session_title]
+        if titles:
+            return f"Agent with {len(sessions)} sessions. Recent work: {'; '.join(titles[-3:])}"
+        return f"Agent with {len(sessions)} sessions."
+
+    recent = summaries[:3]  # sessions already ordered by last_activity_at DESC
+    return f"Agent with {len(sessions)} sessions. " + " ".join(recent)

realign/events/session_summarizer.py

@@ -145,6 +145,9 @@ def update_session_summary_now(db: SQLiteDatabase, session_id: str) -> bool:
 
         # Trigger event summary updates for all parent events (if any)
         _trigger_parent_event_updates(db, session_id)
+
+        # Trigger agent description update if session is linked to an agent
+        _trigger_agent_description_update(db, session_id)
         return True
 
 
@@ -168,6 +171,28 @@ def _trigger_parent_event_updates(db: SQLiteDatabase, session_id: str) -> None:
         logger.warning(f"Failed to trigger event updates: {e}")
 
 
+def _trigger_agent_description_update(db: SQLiteDatabase, session_id: str) -> None:
+    """
+    Trigger agent description update if the session is linked to an agent.
+
+    Args:
+        db: Database instance
+        session_id: ID of the session whose agent should be updated
+    """
+    try:
+        session = db.get_session_by_id(session_id)
+        if session and getattr(session, "agent_id", None):
+            from .agent_summarizer import schedule_agent_description_update
+
+            schedule_agent_description_update(db, session.agent_id)
+            logger.debug(
+                f"Triggered agent description update for agent_id={session.agent_id}"
+            )
+    except Exception as e:
+        # Don't fail session summary update if agent trigger fails
+        logger.warning(f"Failed to trigger agent description update: {e}")
+
+
 def _get_session_summary_prompt() -> str:
     """
     Load session summary prompt with user customization support.