aline-ai 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

realign/triggers/__init__.py

@@ -8,7 +8,6 @@ from .base import TurnTrigger, TurnInfo
 from .claude_trigger import ClaudeTrigger
 from .codex_trigger import CodexTrigger
 from .gemini_trigger import GeminiTrigger
-from .antigravity_trigger import AntigravityTrigger
 from .next_turn_trigger import NextTurnTrigger
 from .registry import TriggerRegistry, get_global_registry
 
@@ -19,7 +18,6 @@ __all__ = [
     "ClaudeTrigger",
     "CodexTrigger",
     "GeminiTrigger",
-    "AntigravityTrigger",
     "TriggerRegistry",
     "get_global_registry",
 ]

realign/triggers/next_turn_trigger.py

@@ -2,7 +2,7 @@
 NextTurnTrigger
 
 A generic delegating trigger that auto-detects the session format and dispatches
-to the appropriate concrete trigger (Claude/Codex/Gemini/Antigravity).
+to the appropriate concrete trigger (Claude/Codex/Gemini).
 
 This is used as a stable default trigger name ("next_turn") across the codebase.
 """
@@ -17,16 +17,15 @@ from .base import TurnInfo, TurnTrigger
 from .claude_trigger import ClaudeTrigger
 from .codex_trigger import CodexTrigger
 from .gemini_trigger import GeminiTrigger
-from .antigravity_trigger import AntigravityTrigger
 
 
 class NextTurnTrigger(TurnTrigger):
     """Auto-detect trigger for any supported session type."""
 
     def select_trigger(self, session_file: Path) -> Optional[TurnTrigger]:
-        # Antigravity sessions are directories under ~/.gemini/antigravity/brain/<uuid>
+        # Skip directories (not a supported session format)
         if session_file.is_dir():
-            return AntigravityTrigger(self.config)
+            return None
 
         # Heuristics based on path
         path_str = str(session_file).lower()
@@ -87,7 +86,7 @@ class NextTurnTrigger(TurnTrigger):
     def get_supported_formats(self) -> List[str]:
         # Union of underlying triggers.
         formats: List[str] = []
-        for cls in (ClaudeTrigger, CodexTrigger, GeminiTrigger, AntigravityTrigger):
+        for cls in (ClaudeTrigger, CodexTrigger, GeminiTrigger):
             try:
                 formats.extend(cls(self.config).get_supported_formats())
             except Exception:

realign/triggers/registry.py

@@ -11,7 +11,6 @@ from .base import TurnTrigger
 from .claude_trigger import ClaudeTrigger
 from .codex_trigger import CodexTrigger
 from .gemini_trigger import GeminiTrigger
-from .antigravity_trigger import AntigravityTrigger
 from .next_turn_trigger import NextTurnTrigger
 
 logger = logging.getLogger(__name__)
@@ -28,7 +27,6 @@ class TriggerRegistry:
             "claude": ClaudeTrigger,
             "codex": CodexTrigger,
             "gemini": GeminiTrigger,
-            "antigravity": AntigravityTrigger,
         }
 
         # 注册所有triggers (用于list_triggers和get_trigger)
@@ -36,7 +34,6 @@ class TriggerRegistry:
         self.register("claude", ClaudeTrigger)
         self.register("codex", CodexTrigger)
         self.register("gemini", GeminiTrigger)
-        self.register("antigravity", AntigravityTrigger)
 
     def register(self, name: str, trigger_class: Type[TurnTrigger]):
         """
@@ -71,7 +68,7 @@ class TriggerRegistry:
         根据session类型获取对应的trigger
 
         Args:
-            session_type: session类型 ("claude", "codex", "gemini", "antigravity")
+            session_type: session类型 ("claude", "codex", "gemini")
             config: 可选的配置字典
 
         Returns:

realign/watcher_core.py

@@ -23,7 +23,7 @@ logger = setup_logger("realign.watcher_core", "watcher_core.log")
 
 
 # Session type detection
-SessionType = Literal["claude", "codex", "gemini", "antigravity", "unknown"]
+SessionType = Literal["claude", "codex", "gemini", "unknown"]
 
 
 def is_path_blacklisted(project_path: Path) -> bool:
@@ -251,6 +251,46 @@ class DialogueWatcher:
         self.user_prompt_signal_dir = self.signal_dir / "user_prompt_submit"
         self.user_prompt_signal_dir.mkdir(parents=True, exist_ok=True)
 
+    def _maybe_link_codex_terminal(self, session_file: Path) -> None:
+        """Best-effort: bind a Codex session file to the most likely active Codex terminal."""
+        try:
+            if self._detect_session_type(session_file) != "codex":
+                return
+        except Exception:
+            return
+
+        try:
+            from .codex_home import terminal_id_from_codex_session_file
+            from .codex_terminal_linker import read_codex_session_meta, select_agent_for_codex_session
+            from .db import get_database
+
+            meta = read_codex_session_meta(session_file)
+            if meta is None:
+                return
+
+            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)
+            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
+
+            db.update_agent(
+                agent_id,
+                provider="codex",
+                session_type="codex",
+                session_id=session_file.stem,
+                transcript_path=str(session_file),
+                cwd=meta.cwd,
+                project_dir=meta.cwd,
+                source="codex:auto-link",
+            )
+        except Exception:
+            return
+
     async def start(self):
         """Start watching session files."""
         if not self.config.mcp_auto_commit:
@@ -540,9 +580,6 @@ class DialogueWatcher:
         current_count = self._count_complete_turns(session_file)
         last_count = self.last_stop_reason_counts.get(session_path, 0)
 
-        if session_type == "antigravity":
-            return [1] if current_count >= 1 else []
-
         if current_count <= last_count:
             return []
 
@@ -974,9 +1011,9 @@ class DialogueWatcher:
             adapter = registry.auto_detect_adapter(session_file)
             if adapter:
                 # Map adapter name to SessionType
-                # Adapter names: "claude", "codex", "gemini", "antigravity"
+                # Adapter names: "claude", "codex", "gemini"
                 name = adapter.name
-                if name in ["claude", "codex", "gemini", "antigravity"]:
+                if name in ["claude", "codex", "gemini"]:
                     return name
 
             return "unknown"
@@ -1050,6 +1087,11 @@ class DialogueWatcher:
                 if old_size is None or old_mtime is None:
                     changed_files.append(Path(path))
                     logger.debug(f"Session file first seen: {Path(path).name} ({size} bytes)")
+                    # Best-effort: link newly discovered Codex sessions to an active Codex terminal.
+                    try:
+                        self._maybe_link_codex_terminal(Path(path))
+                    except Exception:
+                        pass
                     # Reset idle final-commit attempt tracking for new files
                     self.last_final_commit_times.pop(path, None)
                     continue
@@ -1110,6 +1152,11 @@ class DialogueWatcher:
             for session_file in changed_files:
                 if not session_file.exists():
                     continue
+                # Best-effort: keep terminal bindings fresh (especially after watcher restarts).
+                try:
+                    self._maybe_link_codex_terminal(session_file)
+                except Exception:
+                    pass
                 new_turns = self._get_new_completed_turn_numbers(session_file)
                 if new_turns:
                     sessions_to_enqueue.append((session_file, new_turns))
@@ -1956,35 +2003,6 @@ class DialogueWatcher:
                     indent=2,
                 )
 
-            if session_format == "antigravity_markdown":
-                print(
-                    f"[Debug] Extracting Antigravity content for turn {turn_number}",
-                    file=sys.stderr,
-                )
-                # Directly read artifact files from directory (don't rely on trigger.user_message which is empty)
-                session_dir = session_file if session_file.is_dir() else session_file.parent
-                artifacts = ["task.md", "walkthrough.md", "implementation_plan.md"]
-                content_parts = []
-                for filename in artifacts:
-                    path = session_dir / filename
-                    if path.exists():
-                        try:
-                            text = path.read_text(encoding="utf-8")
-                            content_parts.append(f"--- {filename} ---\n{text}")
-                        except Exception as e:
-                            print(f"[Debug] Failed to read {filename}: {e}", file=sys.stderr)
-                full_content = "\n\n".join(content_parts)
-                if full_content:
-                    print(
-                        f"[Debug] Antigravity content extracted: {len(full_content)} chars",
-                        file=sys.stderr,
-                    )
-                    return full_content
-                print(
-                    f"[Debug] Antigravity content empty - no artifact files found", file=sys.stderr
-                )
-                return ""
-
             # For JSONL formats, extract by line numbers
             start_line = group.get("start_line") or (group.get("lines") or [None])[0]
             end_line = group.get("end_line") or (group.get("lines") or [None])[-1]

realign/adapters/antigravity.py

@@ -1,159 +0,0 @@
-"""
-Antigravity IDE Adapter
-
-Handles session discovery for Antigravity IDE (Gemini in IDE).
-Since .pb conversation files are encrypted, this adapter uses
-readable brain artifacts (walkthrough.md, task.md) as session indicators.
-"""
-
-import re
-from pathlib import Path
-from typing import List, Optional, Dict, Any
-
-from .base import SessionAdapter
-from ..triggers.antigravity_trigger import AntigravityTrigger
-
-
-class AntigravityAdapter(SessionAdapter):
-    """Adapter for Antigravity IDE sessions."""
-
-    name = "antigravity"
-    trigger_class = AntigravityTrigger
-
-    def discover_sessions(self) -> List[Path]:
-        """
-        Find all active Antigravity IDE sessions.
-        Returns the directory path for each conversation that contains relevant artifacts.
-        """
-        sessions = []
-        gemini_brain = Path.home() / ".gemini" / "antigravity" / "brain"
-
-        if not gemini_brain.exists():
-            return sessions
-
-        try:
-            for conv_dir in gemini_brain.iterdir():
-                if not conv_dir.is_dir():
-                    continue
-
-                # Check for key artifacts
-                has_artifacts = any(
-                    (conv_dir / filename).exists()
-                    for filename in ["task.md", "walkthrough.md", "implementation_plan.md"]
-                )
-
-                if has_artifacts:
-                    sessions.append(conv_dir)
-        except Exception:
-            pass
-
-        return sessions
-
-    def discover_sessions_for_project(self, project_path: Path) -> List[Path]:
-        """
-        Find sessions for a specific project.
-        """
-        all_sessions = self.discover_sessions()
-        project_sessions = []
-
-        for session in all_sessions:
-            extracted_path = self.extract_project_path(session)
-            if extracted_path and extracted_path == project_path:
-                project_sessions.append(session)
-
-        return project_sessions
-
-    def extract_project_path(self, session_file: Path) -> Optional[Path]:
-        """
-        Infer project root from Antigravity brain artifacts.
-
-        Antigravity stores readable artifacts (task.md / walkthrough.md / implementation_plan.md).
-        We attempt to extract a `file://...` reference, then walk upward to find a `.git` root.
-        """
-        session_dir = session_file if session_file.is_dir() else session_file.parent
-        candidates: List[Path] = []
-
-        artifact_names = ["task.md", "walkthrough.md", "implementation_plan.md"]
-        for name in artifact_names:
-            p = session_dir / name
-            if not p.exists():
-                continue
-            try:
-                text = p.read_text(encoding="utf-8", errors="ignore")
-            except Exception:
-                continue
-
-            # Capture file:// paths from Markdown links or plain text.
-            # Example: file:///Users/me/Project/src/main.py or file://.../src/main.py
-            for match in re.findall(r"file://([^)\s]+)", text):
-                raw = match.strip()
-                if raw.startswith("/"):
-                    candidates.append(Path(raw))
-                else:
-                    # Some tools emit file://Users/... (missing leading slash)
-                    candidates.append(Path("/" + raw))
-
-        for candidate in candidates:
-            try:
-                # Prefer the nearest VCS root
-                path = candidate
-                if path.is_file():
-                    path = path.parent
-                for parent in [path] + list(path.parents):
-                    git_dir = parent / ".git"
-                    if git_dir.exists():
-                        return parent
-            except Exception:
-                continue
-
-        # Fallback: if we found a candidate that exists, return its parent directory.
-        for candidate in candidates:
-            try:
-                if candidate.exists():
-                    return candidate.parent if candidate.is_file() else candidate
-            except Exception:
-                continue
-
-        return None
-
-    def get_session_metadata(self, session_file: Path) -> Dict[str, Any]:
-        """Extract rich metadata from Antigravity brain artifacts."""
-        metadata = super().get_session_metadata(session_file)
-
-        if not session_file.exists():
-            return metadata
-
-        session_dir = session_file if session_file.is_dir() else session_file.parent
-
-        try:
-            # We just return the turn count (always 1 if exists)
-            # No task progress parsing required
-            metadata["turn_count"] = self.trigger.count_complete_turns(session_file)
-
-        except Exception:
-            pass
-
-        return metadata
-
-    def is_session_valid(self, session_file: Path) -> bool:
-        """Check if this is an Antigravity artifact directory."""
-        if not session_file.is_dir():
-            if (
-                session_file.parent.name == "brain"
-                and session_file.parent.parent.name == "antigravity"
-            ):
-                # It's a directory inside brain
-                return True
-            return False
-
-        # Check parent hierarchy
-        # .../.gemini/antigravity/brain/<uuid>
-        try:
-            if (
-                session_file.parent.name == "brain"
-                and session_file.parent.parent.name == "antigravity"
-            ):
-                return True
-        except Exception:
-            pass
-        return False

realign/triggers/antigravity_trigger.py

@@ -1,140 +0,0 @@
-"""
-AntigravityTrigger - Trigger for Antigravity IDE (Markdown artifacts)
-
-Since Antigravity produces walkthrough.md and task.md instead of turn-based JSONL,
-this trigger uses file content/structure as a signal for "turns".
-"""
-
-from datetime import datetime
-from pathlib import Path
-from typing import List, Optional, Dict, Any
-import re
-from .base import TurnTrigger, TurnInfo
-
-
-class AntigravityTrigger(TurnTrigger):
-    """
-    Trigger for Antigravity IDE markdown artifacts.
-    Each distinct Task in task.md or major change in walkthrough.md can be
-    treated as a 'turn'.
-    """
-
-    def get_supported_formats(self) -> List[str]:
-        return ["antigravity_markdown"]
-
-    def detect_session_format(self, session_file: Path) -> Optional[str]:
-        """Detect if this is an Antigravity brain artifact directory."""
-        try:
-            # Check if directory
-            if session_file.is_dir():
-                if session_file.parent.name == "brain" and "antigravity" in str(session_file):
-                    return "antigravity_markdown"
-                return None
-
-            # Legacy/Fallback: Check if file
-            if session_file.suffix == ".md":
-                path_str = str(session_file)
-                if "gemini" in path_str and "brain" in path_str:
-                    return "antigravity_markdown"
-                if ".antigravity" in path_str or "antigravity" in path_str.lower():
-                    return "antigravity_markdown"
-            return None
-        except Exception:
-            return None
-
-    def count_complete_turns(self, session_file: Path) -> int:
-        """
-        Antigravity sessions are effectively "single-turn" persistent states.
-        We return 1 if the artifacts exist, 0 otherwise.
-
-        The watcher will handle change detection via content hashing or mtime,
-        even if this count stays at 1.
-
-        Args:
-            session_file: Path to brain directory (or file)
-
-        Returns:
-            int: 1 if artifacts exist, 0 otherwise.
-        """
-        if not session_file.exists():
-            return 0
-
-        session_dir = session_file if session_file.is_dir() else session_file.parent
-        artifacts = ["task.md", "walkthrough.md", "implementation_plan.md"]
-
-        has_artifacts = False
-        for filename in artifacts:
-            path = session_dir / filename
-            if path.exists():
-                has_artifacts = True
-                break
-
-        return 1 if has_artifacts else 0
-
-    def extract_turn_info(self, session_file: Path, turn_number: int) -> Optional[TurnInfo]:
-        """Extract information by aggregating artifacts."""
-        if not session_file.exists():
-            return None
-
-        # Ensure we point to the directory
-        session_dir = session_file if session_file.is_dir() else session_file.parent
-
-        content_parts = []
-        artifacts = ["task.md", "walkthrough.md", "implementation_plan.md"]
-
-        # Aggregate content
-        for filename in artifacts:
-            path = session_dir / filename
-            if path.exists():
-                text = path.read_text(encoding="utf-8")
-                content_parts.append(f"--- {filename} ---\n{text}")
-
-        full_content = "\n\n".join(content_parts)
-        if not full_content:
-            return None
-
-        # Always use current time for timestamp as this is an evolving state
-        timestamp = datetime.now().isoformat()
-
-        return TurnInfo(
-            turn_number=1,  # Always Turn 1
-            user_message="",  # Empty - full content used elsewhere for summary generation
-            start_line=1,
-            end_line=len(full_content.splitlines()) if full_content else 0,
-            timestamp=timestamp,
-        )
-
-    def is_turn_complete(self, session_file: Path, turn_number: int) -> bool:
-        # For Antigravity, if we have artifacts, it's "complete" in the sense that it exists.
-        return self.count_complete_turns(session_file) >= 1
-
-    def get_detailed_analysis(self, session_file: Path) -> Dict[str, Any]:
-        """
-        Get detailed analysis of the session.
-        Since we treat the state as a single accumulated turn, we return one turn group.
-        """
-        current_turn = self.count_complete_turns(session_file)
-
-        groups = []
-        # Return a single entry representing the current state
-        if current_turn > 0:
-            info = self.extract_turn_info(session_file, 1)
-            if info:
-                groups.append(
-                    {
-                        "turn_number": 1,
-                        "user_message": info.user_message,
-                        "summary_message": "Antigravity Session State",
-                        "turn_status": "completed",
-                        "start_line": info.start_line,
-                        "end_line": info.end_line,
-                        "timestamp": info.timestamp,
-                    }
-                )
-
-        return {
-            "groups": groups,
-            "total_turns": 1 if current_turn > 0 else 0,  # Conceptually one continuous session
-            "latest_turn_id": 1 if current_turn > 0 else 0,
-            "format": "antigravity_markdown",
-        }