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

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.

realign/watcher_core.py

@@ -260,7 +260,7 @@ class DialogueWatcher:
             return
 
         try:
-            from .codex_home import terminal_id_from_codex_session_file
+            from .codex_home import codex_home_owner_from_session_file
             from .codex_terminal_linker import read_codex_session_meta, select_agent_for_codex_session
             from .db import get_database
 
@@ -271,13 +271,50 @@ class DialogueWatcher:
             db = get_database(read_only=False)
             agents = db.list_agents(status="active", limit=1000)
             # Deterministic mapping: session file stored under ~/.aline/codex_homes/<terminal_id>/...
-            agent_id = terminal_id_from_codex_session_file(session_file)
+            owner = codex_home_owner_from_session_file(session_file)
+            agent_id = None
+            agent_info_id = None
+            if owner:
+                if owner[0] == "terminal":
+                    agent_id = owner[1]
+                elif owner[0] == "agent":
+                    agent_info_id = owner[1]
+                    scoped_agents = [
+                        a
+                        for a in agents
+                        if getattr(a, "provider", "") == "codex"
+                        and getattr(a, "status", "") == "active"
+                        and (getattr(a, "source", "") or "") == f"agent:{agent_info_id}"
+                    ]
+                    agent_id = select_agent_for_codex_session(
+                        scoped_agents, session=meta, max_time_delta_seconds=None
+                    )
             if not agent_id:
                 # Fallback heuristic mapping (legacy default ~/.codex/sessions).
                 agent_id = select_agent_for_codex_session(agents, session=meta)
             if not agent_id:
                 return
 
+            owner_agent_info_id = agent_info_id
+            # Get existing agent to preserve agent_info_id in source field
+            existing_agent = db.get_agent_by_id(agent_id)
+            agent_info_id = None
+            existing_source = None
+            if existing_agent:
+                existing_source = existing_agent.source or ""
+                if existing_source.startswith("agent:"):
+                    agent_info_id = existing_source[6:]
+
+            if not agent_info_id and owner_agent_info_id:
+                agent_info_id = owner_agent_info_id
+
+            if existing_source:
+                source = existing_source
+            elif agent_info_id:
+                source = f"agent:{agent_info_id}"
+            else:
+                source = "codex:auto-link"
+
             db.update_agent(
                 agent_id,
                 provider="codex",
@@ -286,8 +323,15 @@ class DialogueWatcher:
                 transcript_path=str(session_file),
                 cwd=meta.cwd,
                 project_dir=meta.cwd,
-                source="codex:auto-link",
+                source=source,
             )
+
+            # Link session to agent_info if available (bidirectional linking)
+            if agent_info_id:
+                try:
+                    db.update_session_agent_id(session_file.stem, agent_info_id)
+                except Exception:
+                    pass
         except Exception:
             return
 
@@ -409,6 +453,7 @@ class DialogueWatcher:
                     project_dir = signal_data.get("project_dir", "")
                     transcript_path = signal_data.get("transcript_path", "")
                     no_track = bool(signal_data.get("no_track", False))
+                    agent_id = signal_data.get("agent_id", "")
 
                     logger.info(f"Stop signal received for session {session_id}")
                     print(f"[Watcher] Stop signal received for {session_id}", file=sys.stderr)
@@ -444,6 +489,7 @@ class DialogueWatcher:
                                     turn_number=target_turn,
                                     session_type=self._detect_session_type(session_file),
                                     no_track=no_track,
+                                    agent_id=agent_id if agent_id else None,
                                 )
                             except Exception as e:
                                 logger.warning(
@@ -505,6 +551,7 @@ class DialogueWatcher:
                 transcript_path = str(signal_data.get("transcript_path") or "")
                 project_dir = str(signal_data.get("project_dir") or "")
                 no_track = bool(signal_data.get("no_track", False))
+                agent_id = str(signal_data.get("agent_id") or "")
 
                 session_file = None
                 if transcript_path and Path(transcript_path).exists():
@@ -534,6 +581,16 @@ class DialogueWatcher:
                     no_track,
                 )
 
+                # Link session to agent if agent_id is provided
+                if agent_id and session_id:
+                    try:
+                        from .db import get_database
+
+                        db = get_database()
+                        db.update_session_agent_id(session_id, agent_id)
+                    except Exception:
+                        pass
+
                 signal_file.unlink(missing_ok=True)
         except Exception as e:
             logger.error(f"Error checking user prompt signals: {e}", exc_info=True)

realign/worker_core.py

@@ -4,6 +4,7 @@ Background worker for durable jobs queue.
 This process consumes jobs from the SQLite `jobs` table:
 - turn_summary: generate/store a turn (LLM + content snapshot)
 - session_summary: aggregate session title/summary from turns
+- agent_description: regenerate agent description from session summaries
 """
 
 from __future__ import annotations
@@ -66,7 +67,7 @@ class AlineWorker:
             try:
                 job = self.db.claim_next_job(
                     worker_id=self.worker_id,
-                    kinds=["turn_summary", "session_summary"],
+                    kinds=["turn_summary", "session_summary", "agent_description"],
                 )
                 if not job:
                     await asyncio.sleep(self.poll_interval_seconds)
@@ -134,6 +135,11 @@ class AlineWorker:
                         )
                 return
 
+            if kind == "agent_description":
+                await self._process_agent_description_job(payload)
+                self.db.finish_job(job_id=job_id, worker_id=self.worker_id, success=True)
+                return
+
             # Unknown job kind: mark as permanently failed to avoid infinite loops.
             self.db.finish_job(
                 job_id=job_id,
@@ -187,6 +193,7 @@ class AlineWorker:
         expected_turns = int(expected_turns_raw) if expected_turns_raw is not None else None
         skip_dedup = bool(payload.get("skip_dedup") or False)
         no_track = bool(payload.get("no_track") or False)
+        agent_id = str(payload.get("agent_id") or "")
 
         if not session_id or turn_number <= 0 or not session_file_path:
             raise ValueError(f"Invalid turn_summary payload: {payload}")
@@ -216,6 +223,13 @@ class AlineWorker:
             no_track=no_track,
         )
 
+        # Link session to agent after commit ensures session exists in DB
+        if agent_id and session_id:
+            try:
+                self.db.update_session_agent_id(session_id, agent_id)
+            except Exception:
+                pass
+
         if created:
             if expected_turns:
                 self._enqueue_session_summary_if_complete(session_id, expected_turns)
@@ -255,3 +269,12 @@ class AlineWorker:
         from .events.session_summarizer import update_session_summary_now
 
         return bool(update_session_summary_now(self.db, session_id))
+
+    async def _process_agent_description_job(self, payload: Dict[str, Any]) -> None:
+        agent_id = str(payload.get("agent_id") or "")
+        if not agent_id:
+            raise ValueError(f"Invalid agent_description payload: {payload}")
+
+        from .events.agent_summarizer import force_update_agent_description
+
+        force_update_agent_description(self.db, agent_id)